Merge from master.

Fix OSX build problems.

.clang-format

@@ -0,0 +1,44 @@
+---
+AccessModifierOffset: -4
+AlignAfterOpenBracket: DontAlign
+AlignArrayOfStructures: Left
+AlignEscapedNewlines: Left
+AllowAllArgumentsOnNextLine: 'true'
+AllowAllConstructorInitializersOnNextLine: 'false'
+AllowAllParametersOfDeclarationOnNextLine: 'true'
+AllowShortBlocksOnASingleLine: 'true'
+AllowShortCaseLabelsOnASingleLine: 'false'
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: None
+AllowShortLoopsOnASingleLine: 'false'
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: 'true'
+AlwaysBreakTemplateDeclarations: 'Yes'
+BinPackArguments: 'false'
+BinPackParameters: 'false'
+BreakBeforeBraces: Allman
+BreakConstructorInitializers: 'AfterColon'
+BreakInheritanceList: AfterColon
+BreakStringLiterals: 'true'
+ColumnLimit: '80'
+ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
+FixNamespaceComments: 'false'
+IncludeBlocks: Preserve
+IndentCaseLabels: 'true'
+IndentWidth: '4'
+IndentWrappedFunctionNames: 'false'
+KeepEmptyLinesAtTheStartOfBlocks: 'true'
+NamespaceIndentation: All
+PointerAlignment: Left
+ReflowComments: 'true'
+SortIncludes: 'false'
+SortUsingDeclarations: 'true'
+SpaceAfterTemplateKeyword: 'true'
+SpaceBeforeAssignmentOperators: 'true'
+SpaceBeforeCtorInitializerColon: 'false'
+SpaceBeforeInheritanceColon: 'true'
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: 'false'
+...

.github/workflows/ccpp.yml

@@ -0,0 +1,97 @@
+name: C/C++ CI
+
+on: [push]
+
+concurrency: 
+  group: environment-${{ github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+    - uses: actions/checkout@v2
+      with:
+        repository: 'davidgiven/fluxengine-testdata'
+        path: 'fluxengine-testdata'
+    - name: apt
+      run: |
+        sudo apt install libudev-dev libsqlite3-dev protobuf-compiler libwxgtk3.0-gtk3-dev libfmt-dev libprotobuf-dev wx-common
+    - name: make
+      run: CXXFLAGS="-Wp,-D_GLIBCXX_ASSERTIONS" make -j`nproc` -C fluxengine
+
+  build-macos-current:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+    - uses: actions/checkout@v2
+      with:
+        repository: 'davidgiven/fluxengine-testdata'
+        path: 'fluxengine-testdata'
+    - name: brew
+      run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
+    - name: make
+      run: gmake -j`nproc` -C fluxengine
+
+    - name: Upload build artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: ${{ github.event.repository.name }}.${{ github.sha }}
+        path: fluxengine/FluxEngine.pkg
+
+  build-windows:
+    runs-on: windows-latest
+
+    steps:
+    - name: setup WSL
+      run: |
+        curl -L https://github.com/WhitewaterFoundry/Fedora-Remix-for-WSL/releases/download/39.0.1/Fedora-Remix-for-WSL-SL_39.0.1.0_x64_arm64.msixbundle -o fedora.msixbundle
+        unzip fedora.msixbundle Fedora-Remix-for-WSL-SL_39.0.1.0_x64.msix
+        unzip Fedora-Remix-for-WSL-SL_39.0.1.0_x64.msix install.tar.gz
+        wsl --update
+        wsl --import fedora fedora install.tar.gz
+        wsl --set-default fedora
+        wsl sh -c 'dnf -y install https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-38-1.noarch.rpm'
+        wsl sh -c 'dnf -y install --setop=install_weak_deps=False gcc gcc-c++ protobuf-c-compiler protobuf-devel fmt-devel systemd-devel sqlite-devel wxGTK-devel mingw32-gcc mingw32-gcc-c++ mingw32-zlib-static mingw32-protobuf-static mingw32-sqlite-static mingw32-wxWidgets3-static mingw32-libpng-static mingw32-libjpeg-static mingw32-libtiff-static mingw32-nsis png2ico'
+
+    - name: fix line endings
+      run: |
+        git config --global core.autocrlf false
+        git config --global core.eol lf
+        
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine-testdata'
+        path: 'fluxengine-testdata'
+
+    - name: run
+      run: |
+        wsl sh -c 'make -C fluxengine BUILDTYPE=windows -j$(nproc)'
+
+    - name: nsis
+      run: |
+        wsl sh -c 'cd fluxengine && strip fluxengine.exe -o fluxengine-stripped.exe'
+        wsl sh -c 'cd fluxengine && strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe'
+        wsl sh -c 'cd fluxengine && makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi'
+
+    - name: zip
+      run: |
+        wsl sh -c 'cd fluxengine && zip -9 fluxengine-windows.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex fluxengine-installer.exe'
+
+    - name: Upload build artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: ${{ github.event.repository.name }}.${{ github.sha }}
+        path: fluxengine/fluxengine-windows.zip

.github/workflows/release.yml

@@ -0,0 +1,125 @@
+name: Autorelease
+
+concurrency: 
+  group: environment-release-${{ github.head_ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - "master"
+
+jobs:
+  dev-release:
+    runs-on: windows-latest
+
+    steps:
+    - name: setup WSL
+      run: |
+        curl -L https://github.com/WhitewaterFoundry/Fedora-Remix-for-WSL/releases/download/39.0.1/Fedora-Remix-for-WSL-SL_39.0.1.0_x64_arm64.msixbundle -o fedora.msixbundle
+        unzip fedora.msixbundle Fedora-Remix-for-WSL-SL_39.0.1.0_x64.msix
+        unzip Fedora-Remix-for-WSL-SL_39.0.1.0_x64.msix install.tar.gz
+        wsl --update
+        wsl --import fedora fedora install.tar.gz
+        wsl --set-default fedora
+        wsl sh -c 'dnf -y install https://github.com/rpmsphere/noarch/raw/master/r/rpmsphere-release-38-1.noarch.rpm'
+        wsl sh -c 'dnf -y install --setop=install_weak_deps=False gcc gcc-c++ protobuf-c-compiler protobuf-devel fmt-devel systemd-devel sqlite-devel wxGTK-devel mingw32-gcc mingw32-gcc-c++ mingw32-zlib-static mingw32-protobuf-static mingw32-sqlite-static mingw32-wxWidgets3-static mingw32-libpng-static mingw32-libjpeg-static mingw32-libtiff-static mingw32-nsis png2ico'
+
+    - name: fix line endings
+      run: |
+        git config --global core.autocrlf false
+        git config --global core.eol lf
+        
+    - uses: actions/checkout@v4
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+
+    - name: run
+      run: |
+        wsl sh -c 'cd fluxengine && make BUILDTYPE=windows -j$(nproc)'
+
+    - name: nsis
+      run: |
+        wsl sh -c 'cd fluxengine && strip fluxengine.exe -o fluxengine-stripped.exe'
+        wsl sh -c 'cd fluxengine && strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe'
+        wsl sh -c 'cd fluxengine && makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi'
+
+    - name: zip
+      run: |
+        wsl sh -c 'cd fluxengine && zip -9 fluxengine-windows.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex fluxengine-installer.exe'
+
+    - name: date
+      run: |
+        echo "RELEASE_DATE=$(date --rfc-3339=date)" >> ${GITHUB_ENV}
+
+    - name: tag
+      uses: EndBug/latest-tag@latest
+      with:
+        tag-name: dev
+        force-branch: false
+        git-directory: 'fluxengine'
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: delete-old-assets
+      uses: mknejp/delete-release-assets@v1
+      with:
+        token: ${{ github.token }}
+        tag: dev
+        assets: | 
+          fluxengine.zip
+          fluxengine-installer.exe
+        fail-if-no-assets: false
+
+    - name: release
+      uses: softprops/action-gh-release@v1
+      with:
+        name: Development build ${{ env.RELEASE_DATE }}
+        files: |
+          fluxengine/fluxengine.zip
+          fluxengine/fluxengine-installer.exe
+        tag_name: dev
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  build-macos:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: brew
+      run: brew install sqlite pkg-config libusb protobuf wxwidgets fmt make coreutils dylibbundler libjpeg
+
+    - name: make
+      run: gmake -j`nproc`
+
+    - name: tag
+      uses: EndBug/latest-tag@latest
+      with:
+        tag-name: dev
+        force-branch: false
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: delete-old-assets
+      uses: mknejp/delete-release-assets@v1
+      with:
+        token: ${{ github.token }}
+        tag: dev
+        assets: | 
+          FluxEngine.pkg
+        fail-if-no-assets: false
+
+    - name: release
+      uses: softprops/action-gh-release@v1
+      with:
+        name: Development build ${{ env.RELEASE_DATE }}
+        files: |
+          FluxEngine.pkg
+        tag_name: dev
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+
+

.gitignore

@@ -1,2 +1,10 @@
 .obj
 .project
+/.ninja*
+/brother120tool
+/brother120tool-*
+/brother240tool
+/brother240tool-*
+/fluxengine
+/fluxengine-*
+/upgrade-flux-file

.hgignore

@@ -1,6 +1,13 @@
 .obj
+.git
 streams
 .*\.flux
 .*\.img
 .*\.raw
+.*\.orig
+.vscode
+remote
+FluxEngine.cydsn/CortexM3
+FluxEngine.cydsn/Generated_Source
+FluxEngine.cydsn/codegentemp
 

.travis.yml

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

FluxEngine.cydsn/FIFOin/API/c.c

@@ -0,0 +1,27 @@
+#include "cyfitter_cfg.h"
+#include "cydevice_trm.h"
+#include "cyfitter.h"
+#include "`$INSTANCE_NAME`_h.h"
+
+void `$INSTANCE_NAME`_Start()
+{
+   `$INSTANCE_NAME`_Init();
+}    
+
+void `$INSTANCE_NAME`_Stop()
+{
+    `$INSTANCE_NAME`_Disable();
+}
+
+void `$INSTANCE_NAME`_Init()
+{    
+    `$INSTANCE_NAME`_Enable();
+    
+}
+void `$INSTANCE_NAME`_Enable()
+{
+}
+
+void `$INSTANCE_NAME`_Disable()
+{
+}

FluxEngine.cydsn/FIFOin/API/h.h

@@ -0,0 +1,50 @@
+#if !defined(`$INSTANCE_NAME`_H)
+#define `$INSTANCE_NAME`_H
+
+#include "cytypes.h"
+#include "cyfitter.h"
+#include "CyLib.h" 
+
+#define `$INSTANCE_NAME`_FIFO_PTR	         ((reg8 *) `$INSTANCE_NAME`_dp__F0_REG)
+
+    /* Macros to clear DP FIFOs.*/
+#define `$INSTANCE_NAME`_CLEAR do { \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0x01u | \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)));\
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0xfeu & \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)));\
+    } while(0)
+
+/* Macros to set FIFO level mode. See the TRM for details */
+#define `$INSTANCE_NAME`_SET_LEVEL_NORMAL \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0xfbu & \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+#define `$INSTANCE_NAME`_SET_LEVEL_MID \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0x04u | \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+
+/* Macros to set FIFO to single-buffer mode. */
+#define `$INSTANCE_NAME`_SINGLE_BUFFER_SET \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0x01u | \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+
+/* Macros to return the FIFO to normal mode. */
+#define `$INSTANCE_NAME`_SINGLE_BUFFER_UNSET \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0xfeu & \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+    
+void `$INSTANCE_NAME`_Enable();
+void `$INSTANCE_NAME`_Disable();
+void `$INSTANCE_NAME`_Start();
+void `$INSTANCE_NAME`_Stop();
+void `$INSTANCE_NAME`_Init();
+
+#endif
+
+/* [] END OF FILE */

FluxEngine.cydsn/FIFOin/FIFOin.v

@@ -0,0 +1,128 @@
+
+//`#start header` -- edit after this line, do not edit this line
+`include "cypress.v"
+//`#end` -- edit above this line, do not edit this line
+
+/* Ultra-simple FIFO in component: a byte is shifted in every clock when req
+ * is high. */
+ 
+module FIFOin (drq, clk, d, req);
+	output  drq;
+	input   clk;
+	input  [7:0] d;
+	input  req;
+
+//`#start body` -- edit after this line, do not edit this line
+
+wire [7:0] pi;
+assign pi = d;
+
+wire load;
+assign load = req;
+
+cy_psoc3_dp #(.cy_dpconfig(
+{
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM0:    */
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM1:     */
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM2:     */
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM3:     */
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM4:     */
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM5:     */
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM6:     */
+	`CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+	`CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+	`CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+	`CS_CMP_SEL_CFGA, /*CFGRAM7:     */
+	8'hFF, 8'h00,	/*CFG9:     */
+	8'hFF, 8'hFF,	/*CFG11-10:     */
+	`SC_CMPB_A1_D1, `SC_CMPA_A1_D1, `SC_CI_B_ARITH,
+	`SC_CI_A_ARITH, `SC_C1_MASK_DSBL, `SC_C0_MASK_DSBL,
+	`SC_A_MASK_DSBL, `SC_DEF_SI_0, `SC_SI_B_DEFSI,
+	`SC_SI_A_DEFSI, /*CFG13-12:     */
+	`SC_A0_SRC_PIN, `SC_SHIFT_SL, 1'h0,
+	1'h0, `SC_FIFO1_BUS, `SC_FIFO0_ALU,
+	`SC_MSB_DSBL, `SC_MSB_BIT0, `SC_MSB_NOCHN,
+	`SC_FB_NOCHN, `SC_CMP1_NOCHN,
+	`SC_CMP0_NOCHN, /*CFG15-14:     */
+	10'h00, `SC_FIFO_CLK__DP,`SC_FIFO_CAP_AX,
+	`SC_FIFO_LEVEL,`SC_FIFO__SYNC,`SC_EXTCRC_DSBL,
+	`SC_WRK16CAT_DSBL /*CFG17-16:     */
+}
+)) dp(
+	/* input          */ .clk(clk),
+	/* input [02:00]  */ .cs_addr(3'b0),    // Program counter
+	/* input          */ .route_si(1'b0),   // Shift in
+	/* input          */ .route_ci(1'b0),   // Carry in
+	/* input          */ .f0_load(load),    // Load FIFO 0
+	/* input          */ .f1_load(1'b0), 	// Load FIFO 1
+	/* input          */ .d0_load(1'b0), 	// Load Data Register 0
+	/* input          */ .d1_load(1'b0), 	// Load Data Register 1
+	/* output         */ .ce0(), 			// Accumulator 0 = Data register 0
+	/* output         */ .cl0(), 			// Accumulator 0 < Data register 0
+	/* output         */ .z0(), 			// Accumulator 0 = 0
+	/* output         */ .ff0(), 			// Accumulator 0 = FF
+	/* output         */ .ce1(), 			// Accumulator [0|1] = Data register 1
+	/* output         */ .cl1(), 			// Accumulator [0|1] < Data register 1
+	/* output         */ .z1(), 			// Accumulator 1 = 0
+	/* output         */ .ff1(), 			// Accumulator 1 = FF
+	/* output         */ .ov_msb(), 		// Operation over flow
+	/* output         */ .co_msb(), 		// Carry out
+	/* output         */ .cmsb(), 			// Carry out
+	/* output         */ .so(), 			// Shift out
+    /* output         */ .f0_bus_stat(drq), // not empty
+	/* output         */ .f0_blk_stat(full),// full
+	/* output         */ .f1_bus_stat(), 	// FIFO 1 status to uP
+	/* output         */ .f1_blk_stat(), 	// FIFO 1 status to DP
+	/* input          */ .ci(1'b0), 		// Carry in from previous stage
+	/* output         */ .co(), 			// Carry out to next stage
+	/* input          */ .sir(1'b0), 		// Shift in from right side
+	/* output         */ .sor(), 			// Shift out to right side
+	/* input          */ .sil(1'b0), 		// Shift in from left side
+	/* output         */ .sol(), 			// Shift out to left side
+	/* input          */ .msbi(1'b0), 		// MSB chain in
+	/* output         */ .msbo(), 			// MSB chain out
+	/* input [01:00]  */ .cei(2'b0),        // Compare equal in from prev stage
+	/* output [01:00] */ .ceo(),            // Compare equal out to next stage
+	/* input [01:00]  */ .cli(2'b0), 	    // Compare less than in from prv stage
+	/* output [01:00] */ .clo(),            // Compare less than out to next stage
+	/* input [01:00]  */ .zi(2'b0),         // Zero detect in from previous stage
+	/* output [01:00] */ .zo(),             // Zero detect out to next stage
+	/* input [01:00]  */ .fi(2'b0), 		// 0xFF detect in from previous stage
+	/* output [01:00] */ .fo(), 	        // 0xFF detect out to next stage
+	/* input [01:00]  */ .capi(2'b0),	    // Capture in from previous stage
+	/* output [01:00] */ .capo(),		    // Capture out to next stage
+	/* input          */ .cfbi(1'b0), 		// CRC Feedback in from previous stage
+	/* output         */ .cfbo(), 			// CRC Feedback out to next stage
+	/* input [07:00]  */ .pi(pi), 		    // Parallel data port
+	/* output [07:00] */ .po()              // Parallel data port
+);
+
+//`#end` -- edit above this line, do not edit this line
+endmodule
+//`#start footer` -- edit after this line, do not edit this line
+//`#end` -- edit above this line, do not edit this line
+
+
+
+

FluxEngine.cydsn/FIFOout/API/c.c

@@ -0,0 +1,27 @@
+#include "cyfitter_cfg.h"
+#include "cydevice_trm.h"
+#include "cyfitter.h"
+#include "`$INSTANCE_NAME`_h.h"
+
+void `$INSTANCE_NAME`_Start()
+{
+   `$INSTANCE_NAME`_Init();
+}    
+
+void `$INSTANCE_NAME`_Stop()
+{
+    `$INSTANCE_NAME`_Disable();
+}
+
+void `$INSTANCE_NAME`_Init()
+{    
+    `$INSTANCE_NAME`_Enable();
+    
+}
+void `$INSTANCE_NAME`_Enable()
+{
+}
+
+void `$INSTANCE_NAME`_Disable()
+{
+}

FluxEngine.cydsn/FIFOout/API/h.h

@@ -0,0 +1,50 @@
+#if !defined(`$INSTANCE_NAME`_H)
+#define `$INSTANCE_NAME`_H
+
+#include "cytypes.h"
+#include "cyfitter.h"
+#include "CyLib.h" 
+
+#define `$INSTANCE_NAME`_FIFO_PTR	         ((reg8 *) `$INSTANCE_NAME`_dp__F0_REG)
+
+    /* Macros to clear DP FIFOs.*/
+#define `$INSTANCE_NAME`_CLEAR do { \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0x01u | \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)));\
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0xfeu & \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)));\
+    } while(0)
+
+/* Macros to set FIFO level mode. See the TRM for details */
+#define `$INSTANCE_NAME`_SET_LEVEL_NORMAL \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0xfbu & \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+#define `$INSTANCE_NAME`_SET_LEVEL_MID \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0x04u | \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+
+/* Macros to set FIFO to single-buffer mode. */
+#define `$INSTANCE_NAME`_SINGLE_BUFFER_SET \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0x01u | \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+
+/* Macros to return the FIFO to normal mode. */
+#define `$INSTANCE_NAME`_SINGLE_BUFFER_UNSET \
+    CY_SET_XTND_REG8(\
+        ((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG), 0xfeu & \
+        CY_GET_XTND_REG8(((reg8 *) `$INSTANCE_NAME`_dp__DP_AUX_CTL_REG)))
+    
+void `$INSTANCE_NAME`_Enable();
+void `$INSTANCE_NAME`_Disable();
+void `$INSTANCE_NAME`_Start();
+void `$INSTANCE_NAME`_Stop();
+void `$INSTANCE_NAME`_Init();
+
+#endif
+
+/* [] END OF FILE */

FluxEngine.cydsn/FIFOout/FIFOout.v

@@ -0,0 +1,169 @@
+
+//`#start header` -- edit after this line, do not edit this line
+`include "cypress.v"
+//`#end` -- edit above this line, do not edit this line
+// Generated on 11/16/2017 at 15:44
+// Component: FIFOout
+module FIFOout (
+    input req,
+	input clk,
+    output [7:0] d,
+	output drq,
+	output empty,
+    output ack
+);
+
+//`#start body` -- edit after this line, do not edit this line
+
+/* Reads from the FIFO are done based on the FIFO being not empty. */
+ 
+wire [7:0] po;
+assign d = po;
+
+localparam STATE_WAITFORREQ = 0;
+localparam STATE_READFROMFIFO = 1;
+localparam STATE_WAITFORNREQ = 2;
+
+reg [1:0] state;
+wire readfromfifo;
+
+assign ack = (state == STATE_WAITFORNREQ);
+assign readfromfifo = (state == STATE_READFROMFIFO);
+
+always @(posedge clk)
+begin
+    case (state)
+        /* opcode is not valid; req is low; wait for req to go high. */
+        STATE_WAITFORREQ:
+        begin
+            if (!empty && req)
+                state <= STATE_READFROMFIFO;
+        end
+        
+        /* Fetch a single value from the FIFO. */
+        STATE_READFROMFIFO:
+            state <= STATE_WAITFORNREQ;
+            
+        /* opcode is valid; ack is high. Wait for req to go low. */
+        STATE_WAITFORNREQ:
+            if (!req)
+                state <= STATE_WAITFORREQ;
+    endcase
+end
+            
+cy_psoc3_dp #(.cy_dpconfig(
+{
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM0: idle */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC___F0, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM1: read from fifo */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM2:           */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM3:           */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM4:           */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM5:           */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM6:           */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM7:           */
+    8'hFF, 8'h00,  /*CFG9:           */
+    8'hFF, 8'hFF,  /*CFG11-10:           */
+    `SC_CMPB_A1_D1, `SC_CMPA_A1_D1, `SC_CI_B_ARITH,
+    `SC_CI_A_ARITH, `SC_C1_MASK_DSBL, `SC_C0_MASK_DSBL,
+    `SC_A_MASK_DSBL, `SC_DEF_SI_0, `SC_SI_B_DEFSI,
+    `SC_SI_A_DEFSI, /*CFG13-12:           */
+    `SC_A0_SRC_ACC, `SC_SHIFT_SL, 1'h0,
+    1'h0, `SC_FIFO1_BUS, `SC_FIFO0_BUS,
+    `SC_MSB_DSBL, `SC_MSB_BIT0, `SC_MSB_NOCHN,
+    `SC_FB_NOCHN, `SC_CMP1_NOCHN,
+    `SC_CMP0_NOCHN, /*CFG15-14:           */
+    10'h00, `SC_FIFO_CLK__DP,`SC_FIFO_CAP_AX,
+    `SC_FIFO_LEVEL,`SC_FIFO_ASYNC,`SC_EXTCRC_DSBL,
+    `SC_WRK16CAT_DSBL /*CFG17-16:           */
+}
+)) dp(
+        /*  input                   */  .reset(1'b0),
+        /*  input                   */  .clk(clk),
+        /*  input   [02:00]         */  .cs_addr({2'b0, readfromfifo}),
+        /*  input                   */  .route_si(1'b0),
+        /*  input                   */  .route_ci(1'b0),
+        /*  input                   */  .f0_load(1'b0),
+        /*  input                   */  .f1_load(1'b0),
+        /*  input                   */  .d0_load(1'b0),
+        /*  input                   */  .d1_load(1'b0),
+        /*  output                  */  .ce0(),
+        /*  output                  */  .cl0(),
+        /*  output                  */  .z0(),
+        /*  output                  */  .ff0(),
+        /*  output                  */  .ce1(),
+        /*  output                  */  .cl1(),
+        /*  output                  */  .z1(),
+        /*  output                  */  .ff1(),
+        /*  output                  */  .ov_msb(),
+        /*  output                  */  .co_msb(),
+        /*  output                  */  .cmsb(),
+        /*  output                  */  .so(),
+        /*  output                  */  .f0_bus_stat(drq), // not full
+        /*  output                  */  .f0_blk_stat(empty), // empty
+        /*  output                  */  .f1_bus_stat(),
+        /*  output                  */  .f1_blk_stat(),
+        
+        /* input                    */  .ci(1'b0),     // Carry in from previous stage
+        /* output                   */  .co(),// Carry out to next stage
+        /* input                    */  .sir(1'b0),    // Shift in from right side
+        /* output                   */  .sor(),        // Shift out to right side
+        /* input                    */  .sil(1'b0),    // Shift in from left side
+        /* output                   */  .sol(),        // Shift out to left side
+        /* input                    */  .msbi(1'b0),   // MSB chain in
+        /* output                   */  .msbo(),       // MSB chain out
+        /* input [01:00]            */  .cei(2'b0),    // Compare equal in from prev stage
+        /* output [01:00]           */  .ceo(),        // Compare equal out to next stage
+        /* input [01:00]            */  .cli(2'b0),    // Compare less than in from prv stage
+        /* output [01:00]           */  .clo(),        // Compare less than out to next stage
+        /* input [01:00]            */  .zi(2'b0),     // Zero detect in from previous stage
+        /* output [01:00]           */  .zo(),         // Zero detect out to next stage
+        /* input [01:00]            */  .fi(2'b0),     // 0xFF detect in from previous stage
+        /* output [01:00]           */  .fo(),         // 0xFF detect out to next stage
+        /* input [01:00]            */  .capi(2'b0),   // Software capture from previous stage
+        /* output [01:00]           */  .capo(),       // Software capture to next stage
+        /* input                    */  .cfbi(1'b0),   // CRC Feedback in from previous stage
+        /* output                   */  .cfbo(),       // CRC Feedback out to next stage
+        /* input [07:00]            */  .pi(8'b0),     // Parallel data port
+        /* output [07:00]           */  .po(po)       // Parallel data port
+);
+
+//`#end` -- edit above this line, do not edit this line
+endmodule
+//`#start footer` -- edit after this line, do not edit this line
+//`#end` -- edit above this line, do not edit this line
+
+
+
+
+
+
+
+
+
+
+
+

FluxEngine.cydsn/FluxEngine.cydwr

@@ -28,13 +28,85 @@
         <Data key="sync_with_bus_clk" value="True" />
         <Data key="user_set_domain" value="False" />
       </Group>
+      <Group key="1a7e8637-3b6b-4e84-839c-0dfc18fdaf5b">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_5" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_5" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
+      <Group key="3f3708ae-fb62-4012-919b-9a3b9a1dfbc2">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_8" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_8" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
+      <Group key="4eef02b9-8ad1-43c4-85f1-b3335faa5fc4">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_3" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_3" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
       <Group key="06c4d5d4-f15f-4b29-a1d0-c24b2e38b1ec">
         <Data key="check_tolerance" value="True" />
         <Data key="clock_version" value="v1" />
         <Data key="derive_type" value="NAMED_FREQ" />
-        <Data key="desired_freq" value="24" />
+        <Data key="desired_freq" value="12" />
         <Data key="desired_unit" value="6" />
-        <Data key="divider" value="1" />
+        <Data key="divider" value="2" />
         <Data key="domain" value="DIGITAL" />
         <Data key="enabled" value="True" />
         <Data key="minus_accuracy" value="0.25" />
@@ -50,7 +122,7 @@
         <Data key="src_clk_name" value="IMO" />
         <Data key="start_on_reset" value="True" />
         <Data key="sync_with_bus_clk" value="True" />
-        <Data key="user_set_domain" value="False" />
+        <Data key="user_set_domain" value="True" />
       </Group>
       <Group key="24cd38f7-f472-4403-837f-86807c8f5333">
         <Data key="check_tolerance" value="True" />
@@ -123,6 +195,54 @@
         <Data key="sync_with_bus_clk" value="True" />
         <Data key="user_set_domain" value="False" />
       </Group>
+      <Group key="71bc291d-84a7-40a8-b7b2-1c8a34326a31">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_FREQ" />
+        <Data key="desired_freq" value="300" />
+        <Data key="desired_unit" value="0" />
+        <Data key="divider" value="65536" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="CLOCK300" />
+        <Data key="named_src_direct_connect" value="False" />
+        <Data key="netlist_name" value="CLOCK300" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="CEF43CFB-0213-49b9-B980-2FFAB81C5B47" />
+        <Data key="src_clk_name" value="IMO" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
+      <Group key="90ce0c72-9f10-44ef-a049-f0f525d59bea">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_FREQ" />
+        <Data key="desired_freq" value="128" />
+        <Data key="desired_unit" value="0" />
+        <Data key="divider" value="65536" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="CLOCK8" />
+        <Data key="named_src_direct_connect" value="False" />
+        <Data key="netlist_name" value="CLOCK8" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="CEF43CFB-0213-49b9-B980-2FFAB81C5B47" />
+        <Data key="src_clk_name" value="IMO" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
       <Group key="349ffa20-8576-4ac3-9a6f-34ef606de6cf">
         <Data key="check_tolerance" value="True" />
         <Data key="clock_version" value="v1" />
@@ -146,6 +266,29 @@
         <Data key="sync_with_bus_clk" value="True" />
         <Data key="user_set_domain" value="False" />
       </Group>
+      <Group key="4033c29d-f4bc-4e94-ac95-aa587e869f88/696a0979-21fc-4185-bf38-6c79febcde7a">
+        <Data key="check_tolerance" value="False" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="AUTO" />
+        <Data key="desired_freq" value="1600000" />
+        <Data key="desired_unit" value="0" />
+        <Data key="divider" value="40" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="OUTPUT_VOLTAGE_ADC_theACLK" />
+        <Data key="netlist_name" value="\OUTPUT_VOLTAGE_ADC:theACLK\" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="61737EF6-3B74-48f9-8B91-F7473A442AE7" />
+        <Data key="src_clk_name" value="MASTER_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
       <Group key="6616e828-6611-4893-a674-66c861d79d6c">
         <Data key="check_tolerance" value="True" />
         <Data key="clock_version" value="v1" />
@@ -193,6 +336,101 @@
         <Data key="sync_with_bus_clk" value="True" />
         <Data key="user_set_domain" value="False" />
       </Group>
+      <Group key="75187c05-9501-4450-b306-6ccdd3bb77db">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_5" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_5" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
+      <Group key="09974428-e912-491f-8d2f-361ba50e7599">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_6" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_6" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
+      <Group key="a5825a94-fa18-4e4f-a843-bc687cacbd56/696a0979-21fc-4185-bf38-6c79febcde7a">
+        <Data key="check_tolerance" value="False" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="AUTO" />
+        <Data key="desired_freq" value="1600000" />
+        <Data key="desired_unit" value="0" />
+        <Data key="divider" value="40" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="INPUT_VOLTAGE_ADC_theACLK" />
+        <Data key="netlist_name" value="\INPUT_VOLTAGE_ADC:theACLK\" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="61737EF6-3B74-48f9-8B91-F7473A442AE7" />
+        <Data key="src_clk_name" value="MASTER_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
+      <Group key="b762c287-7f87-4b21-982e-84be01dc5115">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_2" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_2" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
       <Group key="b0162966-0060-4af5-82d1-fcb491ad7619/be0a0e37-ad17-42ca-b5a1-1a654d736358">
         <Data key="check_tolerance" value="True" />
         <Data key="clock_version" value="v1" />
@@ -216,6 +454,30 @@
         <Data key="sync_with_bus_clk" value="True" />
         <Data key="user_set_domain" value="False" />
       </Group>
+      <Group key="b722443b-8f81-46dc-bf9b-c95eb62bc181">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_1" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_1" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
       <Group key="cb7e877c-9fb4-4fc1-a708-f1e48eb5a68c">
         <Data key="check_tolerance" value="True" />
         <Data key="clock_version" value="v1" />
@@ -240,6 +502,30 @@
         <Data key="sync_with_bus_clk" value="True" />
         <Data key="user_set_domain" value="False" />
       </Group>
+      <Group key="d3075dc6-05c8-4dc9-9959-cf7014c0e66f">
+        <Data key="check_tolerance" value="True" />
+        <Data key="clock_version" value="v1" />
+        <Data key="derive_type" value="NAMED_DIVIDER" />
+        <Data key="desired_freq" value="0" />
+        <Data key="desired_unit" value="15" />
+        <Data key="divider" value="0" />
+        <Data key="domain" value="DIGITAL" />
+        <Data key="enabled" value="True" />
+        <Data key="minus_accuracy" value="0.25" />
+        <Data key="minus_tolerance" value="5" />
+        <Data key="name" value="Clock_7" />
+        <Data key="named_src_direct_connect" value="True" />
+        <Data key="netlist_name" value="Clock_7" />
+        <Data key="placement" value="AUTO" />
+        <Data key="plus_accuracy" value="0.25" />
+        <Data key="plus_tolerance" value="5" />
+        <Data key="scope" value="LOCAL" />
+        <Data key="src_clk_id" value="75C2148C-3656-4d8a-846D-0CAE99AB6FF7" />
+        <Data key="src_clk_name" value="BUS_CLK" />
+        <Data key="start_on_reset" value="True" />
+        <Data key="sync_with_bus_clk" value="True" />
+        <Data key="user_set_domain" value="False" />
+      </Group>
       <Group key="e4a53a4c-40e1-4747-a72a-10193ffdf31c">
         <Data key="check_tolerance" value="True" />
         <Data key="clock_version" value="v1" />
@@ -528,49 +814,70 @@
   </Group>
   <Group key="Component">
     <Group key="v1">
-      <Data key="cy_boot" value="cy_boot_v5_80" />
+      <Data key="cy_boot" value="cy_boot_v6_10" />
       <Data key="Em_EEPROM_Dynamic" value="Em_EEPROM_Dynamic_v2_20" />
-      <Data key="LIN_Dynamic" value="LIN_Dynamic_v4_0" />
+      <Data key="LIN_Dynamic" value="LIN_Dynamic_v6_0" />
     </Group>
   </Group>
   <Data key="DataVersionKey" value="2" />
   <Group key="DWRInstGuidMapping">
     <Group key="Clock">
       <Data key="0b2f9bbb-00ce-4115-a788-ffb9d046a9e5" value="Clock_4" />
+      <Data key="1a7e8637-3b6b-4e84-839c-0dfc18fdaf5b" value="Clock_5" />
+      <Data key="3f3708ae-fb62-4012-919b-9a3b9a1dfbc2" value="Clock_8" />
+      <Data key="4eef02b9-8ad1-43c4-85f1-b3335faa5fc4" value="Clock_3" />
       <Data key="06c4d5d4-f15f-4b29-a1d0-c24b2e38b1ec" value="CounterClock" />
       <Data key="24cd38f7-f472-4403-837f-86807c8f5333" value="PULSE_CLOCK" />
       <Data key="63ed4137-0b09-4256-8a27-35c9a2653f1a" value="Clock_2" />
       <Data key="66f14071-bddd-4b4d-a9aa-a129cceaa7b6" value="Clock_3" />
+      <Data key="71bc291d-84a7-40a8-b7b2-1c8a34326a31" value="CLOCK300" />
+      <Data key="90ce0c72-9f10-44ef-a049-f0f525d59bea" value="CLOCK8" />
       <Data key="349ffa20-8576-4ac3-9a6f-34ef606de6cf" value="Clock_1" />
+      <Data key="4033c29d-f4bc-4e94-ac95-aa587e869f88/696a0979-21fc-4185-bf38-6c79febcde7a" value="OUTPUT_VOLTAGE_ADC_theACLK" />
       <Data key="6616e828-6611-4893-a674-66c861d79d6c" value="SignalSamplingClock" />
       <Data key="12664fc6-9d70-44b1-8a49-887a292e1b7f" value="Clock_3" />
+      <Data key="75187c05-9501-4450-b306-6ccdd3bb77db" value="Clock_5" />
+      <Data key="09974428-e912-491f-8d2f-361ba50e7599" value="Clock_6" />
+      <Data key="a5825a94-fa18-4e4f-a843-bc687cacbd56/696a0979-21fc-4185-bf38-6c79febcde7a" value="INPUT_VOLTAGE_ADC_theACLK" />
+      <Data key="b762c287-7f87-4b21-982e-84be01dc5115" value="Clock_2" />
       <Data key="b0162966-0060-4af5-82d1-fcb491ad7619/be0a0e37-ad17-42ca-b5a1-1a654d736358" value="UART_IntClock" />
+      <Data key="b722443b-8f81-46dc-bf9b-c95eb62bc181" value="Clock_1" />
       <Data key="cb7e877c-9fb4-4fc1-a708-f1e48eb5a68c" value="CounterClock" />
+      <Data key="d3075dc6-05c8-4dc9-9959-cf7014c0e66f" value="Clock_7" />
       <Data key="e4a53a4c-40e1-4747-a72a-10193ffdf31c" value="Clock_1" />
       <Data key="efd5f185-0c32-4824-ba72-3ceb5356f5a7" value="Clock_1" />
     </Group>
     <Group key="Pin">
+      <Data key="3e1862bb-be82-47b0-9549-7ebfe76b6f7b" value="Pin_2" />
       <Data key="4a398466-709f-4228-9500-96178658e13e" value="RDATA" />
       <Data key="5a3407c1-b434-4438-a7b4-b9dfd2280495" value="MOTEA" />
       <Data key="8d318d8b-cf7b-4b6b-b02c-ab1c5c49d0ba" value="SW1" />
+      <Data key="8fc20a4f-e4d1-44b3-a5d4-546e8628d61e" value="LED" />
+      <Data key="12e00eac-69b5-4717-85c8-25ef6b224d4c" value="DEBUG_PINS" />
       <Data key="41e2d8ed-5494-4d8c-8ff7-f4f789cece51" value="REDWC" />
       <Data key="264be2d3-9481-494b-8d9c-c1905a45e9cc" value="FDD" />
       <Data key="472f8fdb-f772-44fb-8897-cc690694237b" value="WDATA" />
       <Data key="736cb12b-c863-43d4-a8f0-42f06023f8b5" value="SIDE1" />
       <Data key="4249c923-fcff-453b-8629-bec6fddd00c1" value="STEP" />
+      <Data key="27315b0e-6a8c-4b7f-be77-73ab434fa803" value="Pin_1" />
       <Data key="1425177d-0d0e-4468-8bcc-e638e5509a9b" value="UartRx" />
       <Data key="a5d987c6-e45b-45b9-ad93-656fab06d720" value="TRK00" />
       <Data key="a93ef5b3-00f4-42c0-8fad-0e275a7e2537" value="MOTEB" />
+      <Data key="b8380fb7-fdb8-449f-bd8d-c4ca96cdf55a" value="DEBUG_PINS" />
+      <Data key="bc2e8987-db82-469c-bf6f-22fd3464cc70" value="DEBUG_PINS" />
       <Data key="bc5d52a1-1b25-4aa0-9ba9-3f81d122772f" value="DEBUG_PINS" />
       <Data key="beca5e2d-f70f-4900-a4db-7eca1ed3126e/8b77a6c4-10a0-4390-971c-672353e2a49c" value="USBFS_Dm" />
       <Data key="beca5e2d-f70f-4900-a4db-7eca1ed3126e/618a72fc-5ddd-4df5-958f-a3d55102db42" value="USBFS_Dp" />
       <Data key="c5367cde-21d5-4866-9a32-d16abfea0c61" value="WPT" />
       <Data key="d19368c5-6855-41bb-a9ff-808938abef00" value="INDEX" />
       <Data key="e9f14b5a-b2bf-49b8-98f3-d7b5a43ace8d" value="DRVSB" />
-      <Data key="e851a3b9-efb8-48be-bbb8-b303b216c393" value="LED" />
+      <Data key="e16b5ef8-00d3-40a4-bc1c-194983c8eb3d" value="LOW_CURRENT" />
+      <Data key="e851a3b9-efb8-48be-bbb8-b303b216c393" value="INDEX300" />
       <Data key="e51063a9-4fad-40c7-a06b-7cc4b137dc18" value="DSKCHG" />
       <Data key="ea7ee228-8b3f-426c-8bb8-cd7a81937769" value="DIR" />
       <Data key="ed092b9b-d398-4703-be89-cebf998501f6" value="UartTx" />
+      <Data key="f9a7371a-8a7d-4144-8b08-69e3d2a3a663" value="INDEX360" />
+      <Data key="fbd1f839-40f9-498e-a48b-5f3048ea5c3d/52f31aa9-2f0a-497d-9a1f-1424095e13e6" value="UART_tx" />
       <Data key="fede1767-f3fd-4021-b3d7-8f9d88f36f9b" value="DRVSA" />
       <Data key="fff78075-035e-43d7-8577-bc5be4d21926" value="WGATE" />
     </Group>
@@ -3659,6 +3966,11 @@
     </Group>
   </Group>
   <Group key="Pin2">
+    <Group key="3e1862bb-be82-47b0-9549-7ebfe76b6f7b">
+      <Group key="0">
+        <Data key="Port Format" value="0,6" />
+      </Group>
+    </Group>
     <Group key="4a398466-709f-4228-9500-96178658e13e">
       <Group key="0">
         <Data key="Port Format" value="1,5" />
@@ -3674,6 +3986,25 @@
         <Data key="Port Format" value="2,2" />
       </Group>
     </Group>
+    <Group key="8fc20a4f-e4d1-44b3-a5d4-546e8628d61e">
+      <Group key="0">
+        <Data key="Port Format" value="2,1" />
+      </Group>
+    </Group>
+    <Group key="12e00eac-69b5-4717-85c8-25ef6b224d4c">
+      <Group key="0">
+        <Data key="Port Format" value="2,2" />
+      </Group>
+      <Group key="1">
+        <Data key="Port Format" value="2,3" />
+      </Group>
+      <Group key="2">
+        <Data key="Port Format" value="2,4" />
+      </Group>
+      <Group key="3">
+        <Data key="Port Format" value="2,0" />
+      </Group>
+    </Group>
     <Group key="41e2d8ed-5494-4d8c-8ff7-f4f789cece51">
       <Group key="0">
         <Data key="Port Format" value="2,7" />
@@ -3741,6 +4072,11 @@
         <Data key="Port Format" value="1,0" />
       </Group>
     </Group>
+    <Group key="27315b0e-6a8c-4b7f-be77-73ab434fa803">
+      <Group key="0">
+        <Data key="Port Format" value="0,7" />
+      </Group>
+    </Group>
     <Group key="1425177d-0d0e-4468-8bcc-e638e5509a9b">
       <Group key="0">
         <Data key="Port Format" value="12,6" />
@@ -3756,6 +4092,43 @@
         <Data key="Port Format" value="12,1" />
       </Group>
     </Group>
+    <Group key="b8380fb7-fdb8-449f-bd8d-c4ca96cdf55a">
+      <Group key="0">
+        <Data key="Port Format" value="2,5" />
+      </Group>
+      <Group key="1">
+        <Data key="Port Format" value="2,4" />
+      </Group>
+      <Group key="2">
+        <Data key="Port Format" value="2,3" />
+      </Group>
+    </Group>
+    <Group key="bc2e8987-db82-469c-bf6f-22fd3464cc70">
+      <Group key="0">
+        <Data key="Port Format" value="0,0" />
+      </Group>
+      <Group key="1">
+        <Data key="Port Format" value="0,1" />
+      </Group>
+      <Group key="2">
+        <Data key="Port Format" value="0,2" />
+      </Group>
+      <Group key="3">
+        <Data key="Port Format" value="0,3" />
+      </Group>
+      <Group key="4">
+        <Data key="Port Format" value="0,4" />
+      </Group>
+      <Group key="5">
+        <Data key="Port Format" value="0,5" />
+      </Group>
+      <Group key="6">
+        <Data key="Port Format" value="0,6" />
+      </Group>
+      <Group key="7">
+        <Data key="Port Format" value="0,7" />
+      </Group>
+    </Group>
     <Group key="bc5d52a1-1b25-4aa0-9ba9-3f81d122772f">
       <Group key="0">
         <Data key="Port Format" value="0,5" />
@@ -3789,9 +4162,14 @@
         <Data key="Port Format" value="12,3" />
       </Group>
     </Group>
+    <Group key="e16b5ef8-00d3-40a4-bc1c-194983c8eb3d">
+      <Group key="0">
+        <Data key="Port Format" value="3,2" />
+      </Group>
+    </Group>
     <Group key="e851a3b9-efb8-48be-bbb8-b303b216c393">
       <Group key="0">
-        <Data key="Port Format" value="2,1" />
+        <Data key="Port Format" value="3,0" />
       </Group>
     </Group>
     <Group key="e51063a9-4fad-40c7-a06b-7cc4b137dc18">
@@ -3809,6 +4187,16 @@
         <Data key="Port Format" value="12,7" />
       </Group>
     </Group>
+    <Group key="f9a7371a-8a7d-4144-8b08-69e3d2a3a663">
+      <Group key="0">
+        <Data key="Port Format" value="3,1" />
+      </Group>
+    </Group>
+    <Group key="fbd1f839-40f9-498e-a48b-5f3048ea5c3d/52f31aa9-2f0a-497d-9a1f-1424095e13e6">
+      <Group key="0">
+        <Data key="Port Format" value="12,7" />
+      </Group>
+    </Group>
     <Group key="fede1767-f3fd-4021-b3d7-8f9d88f36f9b">
       <Group key="0">
         <Data key="Port Format" value="12,2" />
@@ -3834,7 +4222,7 @@
     <Data key="CYDEV_ECC_ENABLE" value="False" />
     <Data key="CYDEV_HEAP_SIZE" value="0x80" />
     <Data key="CYDEV_INSTRUCT_CACHE_ENABLED" value="True" />
-    <Data key="CYDEV_PROTECTION_ENABLE" value="False" />
+    <Data key="CYDEV_PROTECTION_ENABLE" value="True" />
     <Data key="CYDEV_STACK_SIZE" value="0x0800" />
     <Data key="CYDEV_TEMPERATURE" value="0C - 85/125C" />
     <Data key="CYDEV_TRACE_ENABLED" value="False" />

FluxEngine.cydsn/Sampler/Sampler.v

@@ -0,0 +1,96 @@
+
+//`#start header` -- edit after this line, do not edit this line
+`include "cypress.v"
+
+//`#end` -- edit above this line, do not edit this line
+// Generated on 12/11/2019 at 21:18
+// Component: Sampler
+module Sampler (
+	output [2:0] debug_state,
+	output reg [7:0] opcode,
+	output  reg       req,
+	input   clock,
+	input   index,
+	input   rdata,
+	input   reset,
+	input   sampleclock
+);
+
+//`#start body` -- edit after this line, do not edit this line
+
+// NOTE: Reset pulse is used in both clock domains, and must be long enough
+// to be detected in both.
+
+reg [5:0] counter;
+
+reg index_edge;
+reg rdata_edge;
+
+reg req_toggle;
+
+reg rdata_toggle;
+reg old_rdata_toggle;
+
+reg index_toggle;
+reg old_index_toggle;
+
+always @(posedge rdata)
+begin
+    rdata_toggle <= ~rdata_toggle;
+end
+
+always @(posedge index)
+begin
+    index_toggle <= ~index_toggle;
+end
+
+always @(posedge sampleclock)
+begin
+    if (reset)
+    begin
+        old_rdata_toggle <= 0;
+        old_index_toggle <= 0;
+        
+        index_edge <= 0;
+        rdata_edge <= 0;
+        counter <= 0;
+        req_toggle <= 0;
+    end
+    else
+    begin
+        /* If data_toggle or index_toggle have changed state, this means that they've
+         * gone high since the last sampleclock. */
+         
+        index_edge <= index_toggle != old_index_toggle;
+        old_index_toggle <= index_toggle;
+        
+        rdata_edge <= rdata_toggle != old_rdata_toggle;
+        old_rdata_toggle <= rdata_toggle;
+        
+        if (rdata_edge || index_edge || (counter == 6'h3f)) begin
+            opcode <= { rdata_edge, index_edge, counter };
+            req_toggle <= ~req_toggle;
+            counter <= 1;   /* remember to count this tick */
+        end else begin
+            counter <= counter + 1;
+        end
+    end
+end
+
+reg req_toggle_q;
+
+always @(posedge clock)
+begin
+    if (reset) begin
+        req_toggle_q <= 0;
+        req <= 0;
+    end else begin
+        req_toggle_q <= req_toggle;
+        req <= (req_toggle != req_toggle_q);
+    end
+end
+
+//`#end` -- edit above this line, do not edit this line
+endmodule
+//`#start footer` -- edit after this line, do not edit this line
+//`#end` -- edit above this line, do not edit this line

FluxEngine.cydsn/Sequencer/Sequencer.v

@@ -0,0 +1,95 @@
+
+//`#start header` -- edit after this line, do not edit this line
+`include "cypress.v"
+//`#end` -- edit above this line, do not edit this line
+// Generated on 11/24/2019 at 17:25
+// Component: Sequencer
+module Sequencer (
+	output req, /* request new data on leading edge */
+	output wdata,
+    output [2:0] debug_state,
+	input clock,
+	input dataclock, /* incoming data on leading edge */
+	input [7:0] opcode,
+    input index,
+    input sampleclock,
+    input reset
+);
+
+//`#start body` -- edit after this line, do not edit this line
+
+localparam STATE_LOAD = 0;
+localparam STATE_WRITING = 1;
+
+reg state;
+reg [5:0] countdown;
+reg pulsepending;
+
+assign req = (!reset && (state == STATE_LOAD));
+assign wdata = (!reset && (state == STATE_WRITING) && (countdown == 0) && pulsepending);
+assign debug_state = 0;
+
+reg olddataclock;
+wire dataclocked;
+always @(posedge clock) olddataclock <= dataclock;
+assign dataclocked = !olddataclock && dataclock;
+
+reg oldsampleclock;
+reg sampleclocked;
+
+reg oldindex;
+wire indexed;
+always @(posedge clock) oldindex <= index;
+assign indexed = !oldindex && index;
+
+always @(posedge clock)
+begin
+    if (reset)
+    begin
+        state <= STATE_LOAD;
+        countdown <= 0;
+        pulsepending <= 0;
+        oldsampleclock <= 0;
+    end
+    else
+    begin
+        if (!oldsampleclock && sampleclock)
+            sampleclocked <= 1;
+        oldsampleclock <= sampleclock;
+            
+        case (state)
+            STATE_LOAD:
+            begin
+                /* A posedge on dataclocked indicates that another opcode has
+                 * arrived. */
+                if (dataclocked)
+                begin
+                    pulsepending <= opcode[7];
+                    if (opcode[5:0] == 0)
+                        countdown <= 0;
+                    else
+                        countdown <= opcode[5:0] - 1; /* compensate for extra tick in state machine */
+                    
+                    state <= STATE_WRITING;
+                end
+            end
+            
+            STATE_WRITING:
+            begin
+                if (sampleclocked)
+                begin
+                    if (countdown == 0)
+                        state <= STATE_LOAD;
+                    else
+                        countdown <= countdown - 1;
+                    sampleclocked <= 0;
+                end
+            end
+        endcase
+    end
+end
+
+//`#end` -- edit above this line, do not edit this line
+endmodule
+//`#start footer` -- edit after this line, do not edit this line
+//`#end` -- edit above this line, do not edit this line

FluxEngine.cydsn/SuperCounter/SuperCounter.v

@@ -0,0 +1,156 @@
+
+//`#start header` -- edit after this line, do not edit this line
+`include "cypress.v"
+//`#end` -- edit above this line, do not edit this line
+// Generated on 11/16/2017 at 15:44
+// Component: FIFOout
+module SuperCounter (
+	input clk,
+    input reset,
+    input count,
+    output [7:0] d,
+	output drq,
+	output empty,
+    output ack
+);
+
+//`#start body` -- edit after this line, do not edit this line
+
+parameter ResetValue = 0;
+parameter Delta = 1;
+    
+wire [7:0] po;
+assign d = po;
+
+localparam STATE_RESET = 0;
+localparam STATE_WAIT = 1;
+localparam STATE_ADD = 2;
+
+reg oldcount;
+wire counted;
+assign counted = count && !oldcount;
+
+always @(posedge clk) oldcount <= count;
+
+wire [2:0] cs;
+assign cs = reset ? STATE_RESET : (counted ? STATE_ADD : STATE_WAIT);
+            
+cy_psoc3_dp #(.d0_init(ResetValue), .d1_init(Delta), 
+.cy_dpconfig(
+{
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC___D0, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM0:  STATE_RESET*/
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC__ALU, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM1:  STATE_WAIT*/
+    `CS_ALU_OP__ADD, `CS_SRCA_A0, `CS_SRCB_D1,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC__ALU, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM2:  STATE_ADD*/
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM3:             */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM4:             */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM5:             */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM6:             */
+    `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,
+    `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,
+    `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,
+    `CS_CMP_SEL_CFGA, /*CFGRAM7:             */
+    8'hFF, 8'h00,  /*CFG9:             */
+    8'hFF, 8'hFF,  /*CFG11-10:             */
+    `SC_CMPB_A1_D1, `SC_CMPA_A1_D1, `SC_CI_B_ARITH,
+    `SC_CI_A_ARITH, `SC_C1_MASK_DSBL, `SC_C0_MASK_DSBL,
+    `SC_A_MASK_DSBL, `SC_DEF_SI_0, `SC_SI_B_DEFSI,
+    `SC_SI_A_DEFSI, /*CFG13-12:             */
+    `SC_A0_SRC_ACC, `SC_SHIFT_SL, 1'h0,
+    1'h0, `SC_FIFO1_BUS, `SC_FIFO0_BUS,
+    `SC_MSB_DSBL, `SC_MSB_BIT0, `SC_MSB_NOCHN,
+    `SC_FB_NOCHN, `SC_CMP1_NOCHN,
+    `SC_CMP0_NOCHN, /*CFG15-14:             */
+    10'h00, `SC_FIFO_CLK__DP,`SC_FIFO_CAP_AX,
+    `SC_FIFO_LEVEL,`SC_FIFO_ASYNC,`SC_EXTCRC_DSBL,
+    `SC_WRK16CAT_DSBL /*CFG17-16:             */
+}
+)) dp(
+        /*  input                   */  .reset(1'b0),
+        /*  input                   */  .clk(clk),
+        /*  input   [02:00]         */  .cs_addr(cs),
+        /*  input                   */  .route_si(1'b0),
+        /*  input                   */  .route_ci(1'b0),
+        /*  input                   */  .f0_load(1'b0),
+        /*  input                   */  .f1_load(1'b0),
+        /*  input                   */  .d0_load(1'b0),
+        /*  input                   */  .d1_load(1'b0),
+        /*  output                  */  .ce0(),
+        /*  output                  */  .cl0(),
+        /*  output                  */  .z0(),
+        /*  output                  */  .ff0(),
+        /*  output                  */  .ce1(),
+        /*  output                  */  .cl1(),
+        /*  output                  */  .z1(),
+        /*  output                  */  .ff1(),
+        /*  output                  */  .ov_msb(),
+        /*  output                  */  .co_msb(),
+        /*  output                  */  .cmsb(),
+        /*  output                  */  .so(),
+        /*  output                  */  .f0_bus_stat(),
+        /*  output                  */  .f0_blk_stat(),
+        /*  output                  */  .f1_bus_stat(),
+        /*  output                  */  .f1_blk_stat(),
+        
+        /* input                    */  .ci(1'b0),     // Carry in from previous stage
+        /* output                   */  .co(),// Carry out to next stage
+        /* input                    */  .sir(1'b0),    // Shift in from right side
+        /* output                   */  .sor(),        // Shift out to right side
+        /* input                    */  .sil(1'b0),    // Shift in from left side
+        /* output                   */  .sol(),        // Shift out to left side
+        /* input                    */  .msbi(1'b0),   // MSB chain in
+        /* output                   */  .msbo(),       // MSB chain out
+        /* input [01:00]            */  .cei(2'b0),    // Compare equal in from prev stage
+        /* output [01:00]           */  .ceo(),        // Compare equal out to next stage
+        /* input [01:00]            */  .cli(2'b0),    // Compare less than in from prv stage
+        /* output [01:00]           */  .clo(),        // Compare less than out to next stage
+        /* input [01:00]            */  .zi(2'b0),     // Zero detect in from previous stage
+        /* output [01:00]           */  .zo(),         // Zero detect out to next stage
+        /* input [01:00]            */  .fi(2'b0),     // 0xFF detect in from previous stage
+        /* output [01:00]           */  .fo(),         // 0xFF detect out to next stage
+        /* input [01:00]            */  .capi(2'b0),   // Software capture from previous stage
+        /* output [01:00]           */  .capo(),       // Software capture to next stage
+        /* input                    */  .cfbi(1'b0),   // CRC Feedback in from previous stage
+        /* output                   */  .cfbo(),       // CRC Feedback out to next stage
+        /* input [07:00]            */  .pi(8'b0),     // Parallel data port
+        /* output [07:00]           */  .po(po)       // Parallel data port
+);
+
+//`#end` -- edit above this line, do not edit this line
+endmodule
+//`#start footer` -- edit after this line, do not edit this line
+//`#end` -- edit above this line, do not edit this line
+
+
+
+
+
+
+
+
+
+
+
+
+
+

FluxEngine.cydsn/patcher.vbs

@@ -1,18 +0,0 @@
-const READ = 1
-const WRITE = 2
-
-filename = "Generated_Source\PSoC5\USBFS_descr.c"
-set fso = CreateObject("Scripting.FileSystemObject")
-
-set file = fso.OpenTextFile(filename, READ)
-text = file.ReadAll
-file.Close
-
-set r = New RegExp
-r.MultiLine = True
-r.Pattern = "/\* +compatibleID.*\n.*"
-text = r.replace(text, "'W', 'I', 'N', 'U', 'S', 'B', 0, 0,")
-
-set file = fso.CreateTextFile(filename, True)
-file.Write text
-file.Close

Makefile

@@ -1,6 +1,96 @@
-all: .obj/build.ninja
-	@ninja -C .obj test
-
-.obj/build.ninja:
-	@mkdir -p .obj
-	meson .obj
+export BUILDTYPE
+BUILDTYPE ?= host
+
+ifeq ($(BUILDTYPE),windows)
+	MINGW = i686-w64-mingw32-
+	CC = $(MINGW)gcc
+	CXX = $(MINGW)g++ -std=c++17
+	CFLAGS += -g -O3
+	CXXFLAGS += \
+		-fext-numeric-literals \
+		-Wno-deprecated-enum-float-conversion \
+		-Wno-deprecated-enum-enum-conversion
+	LDFLAGS += -static
+	AR = $(MINGW)ar
+	PKG_CONFIG = $(MINGW)pkg-config -static
+	WINDRES = $(MINGW)windres
+	WX_CONFIG = /usr/i686-w64-mingw32/sys-root/mingw/bin/wx-config-3.0 --static=yes
+	EXT = .exe
+else
+	CC = gcc
+	CXX = g++ -std=c++17
+	CFLAGS = -g -O3
+	LDFLAGS =
+	AR = ar
+	PKG_CONFIG = pkg-config
+endif
+
+HOSTCC = gcc
+HOSTCXX = g++ -std=c++17
+HOSTCFLAGS = -g -O3
+HOSTLDFLAGS =
+
+REALOBJ = .obj
+OBJ = $(REALOBJ)/$(BUILDTYPE)
+DESTDIR ?=
+PREFIX ?= /usr/local
+BINDIR ?= $(PREFIX)/bin
+
+# Special Windows settings.
+
+ifeq ($(OS), Windows_NT)
+	EXT ?= .exe
+	MINGWBIN = /mingw32/bin
+	CCPREFIX = $(MINGWBIN)/
+	PKG_CONFIG = $(MINGWBIN)/pkg-config
+	WX_CONFIG = /usr/bin/sh $(MINGWBIN)/wx-config --static=yes
+	PROTOC = $(MINGWBIN)/protoc
+	WINDRES = windres
+	LDFLAGS += \
+		-static
+	CXXFLAGS += \
+		-fext-numeric-literals \
+		-Wno-deprecated-enum-float-conversion \
+		-Wno-deprecated-enum-enum-conversion
+
+	# Required to get the gcc run - time libraries on the path.
+	export PATH := $(PATH):$(MINGWBIN)
+endif
+
+# Special OSX settings.
+
+ifeq ($(shell uname),Darwin)
+	LDFLAGS += \
+		-framework IOKit \
+		-framework Foundation 
+endif
+
+.PHONY: all
+all: +all README.md
+
+.PHONY: binaries tests
+binaries: all
+tests: all
+	
+README.md: $(OBJ)/scripts/+mkdocindex/+mkdocindex$(EXT)
+	@echo MKDOC $@
+	@csplit -s -f$(OBJ)/README. README.md '/<!-- FORMATSSTART -->/' '%<!-- FORMATSEND -->%'
+	@(cat $(OBJ)/README.00 && $< && cat $(OBJ)/README.01) > README.md
+
+.PHONY: tests
+
+.PHONY: install install-bin
+install:: all install-bin
+
+clean::
+	$(hide) rm -rf $(REALOBJ)
+
+install-bin:
+	@echo "INSTALL"
+	$(hide) install -D -v "$(OBJ)/src+fluxengine/src+fluxengine" "$(DESTDIR)$(BINDIR)/fluxengine"
+	$(hide) install -D -v "$(OBJ)/src/gui+gui/gui+gui" "$(DESTDIR)$(BINDIR)/fluxengine-gui"
+	$(hide) install -D -v "$(OBJ)/tools+brother120tool/tools+brother120tool" "$(DESTDIR)$(BINDIR)/brother120tool"
+	$(hide) install -D -v "$(OBJ)/tools+brother240tool/tools+brother240tool" "$(DESTDIR)$(BINDIR)/brother240tool"
+	$(hide) install -D -v "$(OBJ)/tools+upgrade-flux-file/tools+upgrade-flux-file" "$(DESTDIR)$(BINDIR)/upgrade-flux-file"
+
+include build/ab.mk

README.md

@@ -2,7 +2,17 @@ FluxEngine
 ==========
 
 (If you're reading this on GitHub, the formatting's a bit messed up. [Try the
-version on cowlark.com instead.](http://cowlark.com/fluxengine/)
+version on cowlark.com instead.](http://cowlark.com/fluxengine/))
+
+**Breaking news!** As of 2022-09-09, there's new [filesystem
+support](doc/filesystem.md). Read (and sometimes write) files directly from
+(and to) your disks, with eight different file systems! It works in the GUI,
+too, which is available for Linux (and other Unix clones), Windows and OSX. See
+the details below.
+
+<div style="text-align: center">
+<a href="doc/screenshot.jpg"><img src="doc/screenshot.jpg" style="width:60%" alt="screenshot of the GUI in action"></a>
+</div>
 
 What?
 -----
@@ -24,10 +34,13 @@ Don't believe me? Watch the demo reel!
 <iframe width="373" height="210" src="https://www.youtube.com/embed/m_s1iw8eW7o" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
 </div>
 
-**Important note.** On 2019-02-09 I did a hardware redesign and moved the pins on
-the board. Sorry for the inconvenience, but it means you don't have to modify
-the board any more to make it work. If you built the hardware prior to then,
-you'll need to adjust it.
+**New!** The FluxEngine client software now works with
+[Greaseweazle](https://github.com/keirf/Greaseweazle/wiki) hardware. So, if you
+can't find a PSoC5 development kit, or don't want to use the Cypress Windows
+tools for programming it, you can use one of these instead. Very nearly all
+FluxEngine features are available with the Greaseweazle and it works out-of-the
+box. See the [dedicated Greaseweazle documentation page](doc/greaseweazle.md)
+for more information.
 
 Where?
 ------
@@ -52,54 +65,86 @@ following friendly articles:
   - [Using a FluxEngine](doc/using.md) ∾ what to do with your new hardware ∾
     flux files and image files ∾ knowing what you're doing
 
-  - [Reading dubious disks](doc/problems.md) ∾ it's not an exact science ∾
-    the sector map ∾ clock detection and the histogram ∾ tuning the clock ∾
-    manual adjustment
+  - [Using Greaseweazle hardware with the FluxEngine client
+    software](doc/greaseweazle.md) ∾ what works ∾ what doesn't work ∾ where to
+    go for help
+
+  - [Configuring for your drive](doc/drives.md) ∾ but I don't have a 80 track
+    drive! ∾ reading and writing 40 track disks ∾ Shugart and Apple II
+
+  - [Direct filesystem access](doc/filesystem.md) ∾ imaging files is a pain
+    ∾ accessing files directly ∾ features and limitation ∾ it works on disk
+    images too, you say?
+    
+  - [Troubleshooting dubious disks](doc/problems.md) ∾ it's not an exact
+    science ∾ the sector map ∾ clock detection and the histogram
+
+  - [Disk densities](doc/driveresponse.md) ∾ what's the difference between an HD
+    and DD disk? ∾ you can't do that with that ∾ measuring your drive's ability to
+    work with exotic formats ∾ I think my drive is broken
 
 Which?
 ------
 
 The current support state is as follows.
 
-Dinosaurs (🦖) have yet to be observed in real life --- I've written the
-decoder based on Kryoflux (or other) dumps I've found. I don't (yet) have
-real, physical disks in my hand to test the capture process.
+Dinosaurs (🦖) have yet to be observed in real life --- I've written the encoder
+and/or decoder based on Kryoflux (or other) dumps I've found. I don't (yet) have
+real, physical disks in my hand to test the capture process, or hardware to
+verify that written disks work.
 
-Unicorns (🦄) are completely real --- this means that I've read actual,
-physical disks with these formats and so know they work.
+Unicorns (🦄) are completely real --- this means that I've read actual, physical
+disks with these formats and/or written real, physical disks and then used them
+on real hardware, and so know they work (or had reports from people who've had
+it work).
 
-### Old disk formats
+If a filesystem is listed, this means that FluxEngine natively supports that
+particular filesystem and can read (and sometimes write, support varies) files
+directly from disks, flux files or disk images. Some formats have multiple
+choices because they can store multiple types of file system.
 
-| Format                                   | Read? | Write? | Notes |
-|:-----------------------------------------|:-----:|:------:|-------|
-| IBM PC compatible                        |  🦄   |        | and compatibles (like the Atari ST) |
-| [Acorn ADFS](doc/disk-acornadfs.md)      |  🦄   |        | single- and double- sided           |
-| [Acorn DFS](doc/disk-acorndfs.md)        |  🦄   |        |                                     |
-| [Ampro Little Board](doc/disk-ampro.md)  |  🦖   |        |                                     |
-| [Apple II DOS 3.3](doc/disk-apple2.md)   |  🦖   |        | doesn't do logical sector remapping |
-| [Amiga](doc/disk-amiga.md)               |  🦄   |        |                                     |
-| [Commodore 64 1541](doc/disk-c64.md)     |  🦖   |        | and probably the other GCR formats  |
-| [Brother 120kB](doc/disk-brother.md)     |  🦄   |        |                                     |
-| [Brother 240kB](doc/disk-brother.md)     |  🦄   |   🦄   |                                     |
-| [Macintosh 800kB](doc/disk-macintosh.md) |  🦖   |        | and probably the 400kB too          |
-| [TRS-80](doc/disk-trs80.md)              |  🦖   |        | a minor variation of the IBM scheme |
+<!-- FORMATSSTART -->
+<!-- This section is automatically generated. Do not edit. -->
+
+| Profile | Format | Read? | Write? | Filesystem? |
+|:--------|:-------|:-----:|:------:|:------------|
+| [`acornadfs`](doc/disk-acornadfs.md) | Acorn ADFS: BBC Micro, Archimedes | 🦖 |  |  |
+| [`acorndfs`](doc/disk-acorndfs.md) | Acorn DFS: Acorn Atom, BBC Micro series | 🦄 |  | ACORNDFS  |
+| [`aeslanier`](doc/disk-aeslanier.md) | AES Lanier "No Problem": 616kB 5.25" 77-track SSDD hard sectored | 🦖 |  |  |
+| [`agat`](doc/disk-agat.md) | Agat: 840kB 5.25" 80-track DS | 🦖 | 🦖 |  |
+| [`amiga`](doc/disk-amiga.md) | Amiga: 880kB 3.5" DSDD | 🦄 | 🦄 | AMIGAFFS  |
+| [`ampro`](doc/disk-ampro.md) | Ampro Little Board: CP/M | 🦖 |  | CPMFS  |
+| [`apple2`](doc/disk-apple2.md) | Apple II: Prodos, Appledos, and CP/M | 🦄 | 🦄 | APPLEDOS CPMFS PRODOS  |
+| [`atarist`](doc/disk-atarist.md) | Atari ST: Almost PC compatible | 🦄 | 🦄 |  |
+| [`bk`](doc/disk-bk.md) | BK: 800kB 5.25"/3.5" 80-track 10-sector DSDD | 🦖 | 🦖 |  |
+| [`brother`](doc/disk-brother.md) | Brother word processors: GCR family | 🦄 | 🦄 | BROTHER120 FATFS  |
+| [`commodore`](doc/disk-commodore.md) | Commodore: 1541, 1581, 8050 and variations | 🦄 | 🦄 | CBMFS  |
+| [`eco1`](doc/disk-eco1.md) | VDS Eco1: CP/M; 1210kB 77-track mixed format DSHD | 🦖 |  | CPMFS  |
+| [`epsonpf10`](doc/disk-epsonpf10.md) | Epson PF-10: CP/M; 3.5" 40-track DSDD | 🦖 |  | CPMFS  |
+| [`f85`](doc/disk-f85.md) | Durango F85: 461kB 5.25" 77-track SS | 🦖 |  |  |
+| [`fb100`](doc/disk-fb100.md) | Brother FB-100: 100kB 3.5" 40-track SSSD | 🦖 |  |  |
+| [`hplif`](doc/disk-hplif.md) | Hewlett-Packard LIF: a variety of disk formats used by HP | 🦄 | 🦄 | LIF  |
+| [`ibm`](doc/disk-ibm.md) | IBM PC: Generic PC 3.5"/5.25" disks | 🦄 | 🦄 | FATFS  |
+| [`icl30`](doc/disk-icl30.md) | ICL Model 30: CP/M; 263kB 35-track DSSD | 🦖 |  | CPMFS  |
+| [`mac`](doc/disk-mac.md) | Macintosh: 400kB/800kB 3.5" GCR | 🦄 | 🦄 | MACHFS  |
+| [`micropolis`](doc/disk-micropolis.md) | Micropolis: 100tpi MetaFloppy disks | 🦄 | 🦄 |  |
+| [`ms2000`](doc/disk-ms2000.md) | : MS2000 Microdisk Development System |  |  | MICRODOS  |
+| [`mx`](doc/disk-mx.md) | DVK MX: Soviet-era PDP-11 clone | 🦖 |  |  |
+| [`n88basic`](doc/disk-n88basic.md) | N88-BASIC: PC8800/PC98 5.25" 77-track 26-sector DSHD | 🦄 | 🦄 |  |
+| [`northstar`](doc/disk-northstar.md) | Northstar: 5.25" hard sectored | 🦄 | 🦄 |  |
+| [`psos`](doc/disk-psos.md) | pSOS: 800kB DSDD with PHILE | 🦄 | 🦄 | PHILE  |
+| [`rolandd20`](doc/disk-rolandd20.md) | Roland D20: 3.5" electronic synthesiser disks | 🦄 | 🦖 | ROLAND  |
+| [`rx50`](doc/disk-rx50.md) | Digital RX50: 400kB 5.25" 80-track 10-sector SSDD | 🦖 | 🦖 |  |
+| [`smaky6`](doc/disk-smaky6.md) | Smaky 6: 308kB 5.25" 77-track 16-sector SSDD, hard sectored | 🦖 |  | SMAKY6  |
+| [`tartu`](doc/disk-tartu.md) | Tartu: The Palivere and variations | 🦄 |  | CPMFS  |
+| [`tids990`](doc/disk-tids990.md) | Texas Instruments DS990: 1126kB 8" DSSD | 🦖 | 🦖 |  |
+| [`tiki`](doc/disk-tiki.md) | Tiki 100: CP/M |  |  | CPMFS  |
+| [`victor9k`](doc/disk-victor9k.md) | Victor 9000 / Sirius One: 1224kB 5.25" DSDD GCR | 🦖 | 🦖 |  |
+| [`zilogmcz`](doc/disk-zilogmcz.md) | Zilog MCZ: 320kB 8" 77-track SSSD hard-sectored | 🦖 |  | ZDOS  |
 {: .datatable }
 
-### Even older disk formats
+<!-- FORMATSEND -->
 
-These formats are for particularly old, weird architectures, even by the
-standards of floppy disks. They've largely been implemented from single flux
-files with no access to physical hardware. Typically the reads were pretty
-bad and I've had to make a number of guesses as to how things work. They do,
-at least, check the CRC so what data's there is probably good.
-
-| Format                                   | Read? | Write? | Notes |
-|:-----------------------------------------|:-----:|:------:|-------|
-| [AES Superplus / No Problem](doc/disk-aeslanier.md) |  🦖   | | hard sectors! |
-| [Durango F85](doc/disk-durangof85.md)    |  🦖   |        | 5.25" |
-| [Victor 9000](doc/disk-victor9k.md)      |  🦖   |        | 8-inch        |
-| [Zilog MCZ](doc/disk-zilogmcz.md)        |  🦖   |        | 8-inch _and_ hard sectors |
-{: .datatable }
 ### Notes
 
   - IBM PC disks are the lowest-common-denominator standard. A number of other
@@ -115,7 +160,7 @@ at least, check the CRC so what data's there is probably good.
     There hasn't been a lot of demand for this yet; if you have a pressing
     need to write weird disks, [please
     ask](https://github.com/davidgiven/fluxengine/issues/new). I haven't
-    implement write support for PC disks because they're boring and I'm lazy,
+    implemented write support for PC disks because they're boring and I'm lazy,
     and also because they vary so much that figuring out how to specify them
     is hard.
 
@@ -169,13 +214,51 @@ There may or may not be anything interesting there.
 License
 -------
 
-Everything here _except the contents of the `dep` directory_ is © 2019 David
-Given and is licensed under the MIT open source license. Please see
+Everything here _except the contents of the `dep` directory_ is © 2022 The
+FluxEngine Authors (mostly me, David Given; see the VCS history for the other
+people) and is licensed under the MIT open source license. Please see
 [COPYING](COPYING) for the full text. The tl;dr is: you can do what you like
 with it provided you don't claim you wrote it.
 
-As an exception, `dep/fmt` contains a copy of [fmt](http://fmtlib.net),
-maintained by Victor Zverovich (`vitaut <https://github.com/vitaut>`) and
-Jonathan Müller (`foonathan <https://github.com/foonathan>`) with
-contributions from many other people. It is licensed under the terms of the
-BSD license. Please see the contents of the directory for the full text.
+As an exception, `dep/emu` contains parts of the OpenBSD C library
+code, maintained by Todd Miller and William A. Rowe (and probably others). It is licensed
+under the terms of the 3-clause BSD license. Please see the contents of the
+directory for the full text. It's been lightly modified by me.
+
+As an exception, `dep/agg` contains parts of the Anti-Grain Antialiasing
+library, written by Maxim Semanarev (and others). It is licensed under the
+terms of the 3-clause BSD license. Please see the contents of the directory for
+the full text. It's been lightly modified by me.
+
+As an exception, `dep/stb` contains parts of the libstb utility library,
+written by Sean T Barett (and others). It is public domain/Unlicense/MIT
+licensed, at your choice. Please see the contents of the directory for the full
+text.
+
+As an exception, `dep/snowhouse` contains the snowhouse assertion library,
+taken from https://github.com/banditcpp/snowhouse. It is Boost Standard License
+1.0 licensed. Please see the contents of the directory for the full text. Note
+that this is only used during the build and no code ends up in the output
+binaries.
+
+As an exception, `dep/libusbp` contains the libusbp library, taken from
+https://github.com/pololu/libusbp. It is MIT licensed. Please see the contents
+of the directory for the full text.
+
+As an exception, `dep/fatfs` contains the fatfs library, taken from
+http://elm-chan.org/fsw/ff/00index_e.html. It is single-clause BSD licensed.
+Please see the contents of the directory for the full text.
+
+As an exception, `dep/adflib` contains the adflib library, written by Laurent
+Clevy et al, taken from https://github.com/lclevy/ADFlib. It is GPL 2.0
+licensed. Please see the contents of the directory for the full text.
+
+As an exception, `dep/hfsutils` contains a partial copy of the hfsutils
+package, written by Robert Leslie et al, taken from
+https://www.mars.org/home/rob/proj/hfs. It is GPL 2.0 licensed. Please see the
+contents of the directory for the full text.
+
+__Important:__ Because of all these exceptions, if you distribute the
+FluxEngine package as a whole, you must comply with the terms of _all_ of the
+licensing terms. This means that __effectively the FluxEngine package is
+distributable under the terms of the GPL 2.0__.

arch/aeslanier/aeslanier.h

@@ -0,0 +1,11 @@
+#ifndef AESLANIER_H
+#define AESLANIER_H
+
+#define AESLANIER_RECORD_SEPARATOR 0x55555122
+#define AESLANIER_SECTOR_LENGTH 256
+#define AESLANIER_RECORD_SIZE (AESLANIER_SECTOR_LENGTH + 5)
+
+extern std::unique_ptr<Decoder> createAesLanierDecoder(
+    const DecoderProto& config);
+
+#endif

arch/aeslanier/aeslanier.proto

@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message AesLanierDecoderProto {}
+

arch/aeslanier/decoder.cc

@@ -0,0 +1,64 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "aeslanier.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include <string.h>
+
+static const FluxPattern SECTOR_PATTERN(32, AESLANIER_RECORD_SEPARATOR);
+
+/* This is actually M2FM, rather than MFM, but it our MFM/FM decoder copes fine
+ * with it. */
+
+class AesLanierDecoder : public Decoder
+{
+public:
+    AesLanierDecoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(SECTOR_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        /* Skip ID mark (we know it's a AESLANIER_RECORD_SEPARATOR). */
+
+        readRawBits(16);
+
+        const auto& rawbits = readRawBits(AESLANIER_RECORD_SIZE * 16);
+        const auto& bytes =
+            decodeFmMfm(rawbits).slice(0, AESLANIER_RECORD_SIZE);
+        const auto& reversed = bytes.reverseBits();
+
+        _sector->logicalTrack = reversed[1];
+        _sector->logicalSide = 0;
+        _sector->logicalSector = reversed[2];
+
+        /* Check header 'checksum' (which seems far too simple to mean much). */
+
+        {
+            uint8_t wanted = reversed[3];
+            uint8_t got = reversed[1] + reversed[2];
+            if (wanted != got)
+                return;
+        }
+
+        /* Check data checksum, which also includes the header and is
+         * significantly better. */
+
+        _sector->data = reversed.slice(1, AESLANIER_SECTOR_LENGTH);
+        uint16_t wanted = reversed.reader().seek(0x101).read_le16();
+        uint16_t got = crc16ref(MODBUS_POLY_REF, _sector->data);
+        _sector->status = (wanted == got) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createAesLanierDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new AesLanierDecoder(config));
+}

arch/agat/agat.cc

@@ -0,0 +1,20 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "agat.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+
+uint8_t agatChecksum(const Bytes& bytes)
+{
+    uint16_t checksum = 0;
+
+    for (uint8_t b : bytes)
+    {
+        if (checksum > 0xff)
+            checksum = (checksum + 1) & 0xff;
+
+        checksum += b;
+    }
+
+    return checksum & 0xff;
+}

arch/agat/agat.h

@@ -0,0 +1,19 @@
+#ifndef AGAT_H
+#define AGAT_H
+
+#define AGAT_SECTOR_SIZE 256
+
+static constexpr uint64_t SECTOR_ID = 0x8924555549111444;
+static constexpr uint64_t DATA_ID = 0x8924555514444911;
+
+class Encoder;
+class EncoderProto;
+class Decoder;
+class DecoderProto;
+
+extern std::unique_ptr<Decoder> createAgatDecoder(const DecoderProto& config);
+extern std::unique_ptr<Encoder> createAgatEncoder(const EncoderProto& config);
+
+extern uint8_t agatChecksum(const Bytes& bytes);
+
+#endif

arch/agat/agat.proto

@@ -0,0 +1,19 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message AgatDecoderProto {}
+
+message AgatEncoderProto {
+	optional double target_clock_period_us = 1
+		[default=2.00, (help)="Data clock period of target format."];
+	optional double target_rotational_period_ms = 2
+		[default=200.0, (help)="Rotational period of target format."];
+	optional int32 post_index_gap_bytes = 3
+		[default=40, (help)="Post-index gap before first sector header."];
+	optional int32 pre_sector_gap_bytes = 4
+		[default=11, (help)="Gap before each sector header."];
+	optional int32 pre_data_gap_bytes = 5
+		[default=2, (help)="Gap before each sector data record."];
+}
+

arch/agat/decoder.cc

@@ -0,0 +1,89 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "agat.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include <string.h>
+
+// clang-format off
+/*
+ * data:    X  X  X  X   X  X  X  X   X  -  -  X   -  X  -  X   -  X  X  -   X  -  X  -  = 0xff956a
+ * flux:   01 01 01 01  01 01 01 01  01 00 10 01  00 01 00 01  00 01 01 00  01 00 01 00  = 0x555549111444
+ * 
+ * data:    X  X  X  X   X  X  X  X   -  X  X  -   X  -  X  -   X  -  -  X   -  X  -  X  = 0xff6a95
+ * flux:   01 01 01 01  01 01 01 01  00 01 01 00  01 00 01 00  01 00 10 01  00 01 00 01  = 0x555514444911
+ *
+ * Each pattern is prefixed with this one:
+ *
+ * data:          -  -   -  X   -  -   X  - = 0x12
+ * flux:    (10) 10 10  10 01  00 10  01 00 = 0xa924
+ * magic:   (10) 10 00  10 01  00 10  01 00 = 0x8924
+ *                  ^
+ *
+ * This seems to be generated by emitting A4 in MFM and then a single 0 bit to
+ * shift it out of phase, so the data bits become clock bits and vice versa.
+ *
+ *           X - X - - X - -  = 0xA4
+ *          0100010010010010  = MFM encoded
+ *           1000100100100100 = with trailing zero
+ *            - - - X - - X - = effective bitstream = 0x12
+ */
+// clang-format on
+
+static const FluxPattern SECTOR_PATTERN(64, SECTOR_ID);
+static const FluxPattern DATA_PATTERN(64, DATA_ID);
+
+static const FluxMatchers ALL_PATTERNS = {&SECTOR_PATTERN, &DATA_PATTERN};
+
+class AgatDecoder : public Decoder
+{
+public:
+    AgatDecoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ALL_PATTERNS);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw64() != SECTOR_ID)
+            return;
+
+        auto bytes = decodeFmMfm(readRawBits(64)).slice(0, 4);
+        if (bytes[3] != 0x5a)
+            return;
+
+        _sector->logicalTrack = bytes[1] >> 1;
+        _sector->logicalSector = bytes[2];
+        _sector->logicalSide = bytes[1] & 1;
+        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
+    }
+
+    void decodeDataRecord() override
+    {
+        if (readRaw64() != DATA_ID)
+            return;
+
+        Bytes bytes = decodeFmMfm(readRawBits((AGAT_SECTOR_SIZE + 2) * 16))
+                          .slice(0, AGAT_SECTOR_SIZE + 2);
+
+        if (bytes[AGAT_SECTOR_SIZE + 1] != 0x5a)
+            return;
+
+        _sector->data = bytes.slice(0, AGAT_SECTOR_SIZE);
+        uint8_t wantChecksum = bytes[AGAT_SECTOR_SIZE];
+        uint8_t gotChecksum = agatChecksum(_sector->data);
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createAgatDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new AgatDecoder(config));
+}

arch/agat/encoder.cc

@@ -0,0 +1,118 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "agat.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "lib/layout.h"
+#include "arch/agat/agat.pb.h"
+#include "lib/encoders/encoders.pb.h"
+
+class AgatEncoder : public Encoder
+{
+public:
+    AgatEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.agat())
+    {
+    }
+
+private:
+    void writeRawBits(uint64_t data, int width)
+    {
+        _cursor += width;
+        _lastBit = data & 1;
+        for (int i = 0; i < width; i++)
+        {
+            unsigned pos = _cursor - i - 1;
+            if (pos < _bits.size())
+                _bits[pos] = data & 1;
+            data >>= 1;
+        }
+    }
+
+    void writeBytes(const Bytes& bytes)
+    {
+        encodeMfm(_bits, _cursor, bytes, _lastBit);
+    }
+
+    void writeByte(uint8_t byte)
+    {
+        Bytes b;
+        b.writer().write_8(byte);
+        writeBytes(b);
+    }
+
+    void writeFillerRawBytes(int count, uint16_t byte)
+    {
+        for (int i = 0; i < count; i++)
+            writeRawBits(byte, 16);
+    };
+
+    void writeFillerBytes(int count, uint8_t byte)
+    {
+        Bytes b{byte};
+        for (int i = 0; i < count; i++)
+            writeBytes(b);
+    };
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        auto trackLayout = Layout::getLayoutOfTrack(
+            trackInfo->logicalTrack, trackInfo->logicalSide);
+
+        double clockRateUs = _config.target_clock_period_us() / 2.0;
+        int bitsPerRevolution =
+            (_config.target_rotational_period_ms() * 1000.0) / clockRateUs;
+        _bits.resize(bitsPerRevolution);
+        _cursor = 0;
+
+        writeFillerRawBytes(_config.post_index_gap_bytes(), 0xaaaa);
+
+        for (const auto& sector : sectors)
+        {
+            /* Header */
+
+            writeFillerRawBytes(_config.pre_sector_gap_bytes(), 0xaaaa);
+            writeRawBits(SECTOR_ID, 64);
+            writeByte(0x5a);
+            writeByte((sector->logicalTrack << 1) | sector->logicalSide);
+            writeByte(sector->logicalSector);
+            writeByte(0x5a);
+
+            /* Data */
+
+            writeFillerRawBytes(_config.pre_data_gap_bytes(), 0xaaaa);
+            auto data = sector->data.slice(0, AGAT_SECTOR_SIZE);
+            writeRawBits(DATA_ID, 64);
+            writeBytes(data);
+            writeByte(agatChecksum(data));
+            writeByte(0x5a);
+        }
+
+        if (_cursor >= _bits.size())
+            error("track data overrun");
+        fillBitmapTo(_bits, _cursor, _bits.size(), {true, false});
+
+        auto fluxmap = std::make_unique<Fluxmap>();
+        fluxmap->appendBits(_bits,
+            calculatePhysicalClockPeriod(_config.target_clock_period_us() * 1e3,
+                _config.target_rotational_period_ms() * 1e6));
+        return fluxmap;
+    }
+
+private:
+    const AgatEncoderProto& _config;
+    uint32_t _cursor;
+    bool _lastBit;
+    std::vector<bool> _bits;
+};
+
+std::unique_ptr<Encoder> createAgatEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new AgatEncoder(config));
+}

arch/amiga/amiga.cc

@@ -0,0 +1,104 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "amiga.h"
+#include "lib/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

@@ -0,0 +1,20 @@
+#ifndef AMIGA_H
+#define AMIGA_H
+
+#include "lib/encoders/encoders.h"
+
+#define AMIGA_SECTOR_RECORD 0xaaaa44894489LL
+
+#define AMIGA_TRACKS_PER_DISK 80
+#define AMIGA_SECTORS_PER_TRACK 11
+#define AMIGA_RECORD_SIZE 0x21c
+
+extern std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config);
+extern std::unique_ptr<Encoder> createAmigaEncoder(const EncoderProto& config);
+
+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/amiga.proto

@@ -0,0 +1,13 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message AmigaDecoderProto {}
+
+message AmigaEncoderProto {
+	optional double clock_rate_us = 1
+		[default=2.00, (help)="Encoded data clock rate."];
+	optional double post_index_gap_ms = 2
+		[default=0.5, (help)="Post-index gap before first sector header."];
+}
+

arch/amiga/decoder.cc

@@ -0,0 +1,84 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "amiga.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include "lib/decoders/decoders.pb.h"
+#include <string.h>
+#include <algorithm>
+
+/*
+ * Amiga disks use MFM but it's not quite the same as IBM MFM. They only use
+ * a single type of record with a different marker byte.
+ *
+ * See the big comment in the IBM MFM decoder for the gruesome details of how
+ * MFM works.
+ */
+
+static const FluxPattern SECTOR_PATTERN(48, AMIGA_SECTOR_RECORD);
+
+class AmigaDecoder : public Decoder
+{
+public:
+    AmigaDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.amiga())
+    {
+    }
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(SECTOR_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw48() != AMIGA_SECTOR_RECORD)
+            return;
+
+        const auto& rawbits = readRawBits(AMIGA_RECORD_SIZE * 16);
+        if (rawbits.size() < (AMIGA_RECORD_SIZE * 16))
+            return;
+        const auto& rawbytes = toBytes(rawbits).slice(0, AMIGA_RECORD_SIZE * 2);
+        const auto& bytes = decodeFmMfm(rawbits).slice(0, AMIGA_RECORD_SIZE);
+
+        const uint8_t* ptr = bytes.begin();
+
+        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 =
+            amigaDeinterleave(ptr, 4).reader().read_be32();
+        uint32_t gotheaderchecksum = amigaChecksum(rawbytes.slice(0, 40));
+        if (gotheaderchecksum != wantedheaderchecksum)
+            return;
+
+        uint32_t wanteddatachecksum =
+            amigaDeinterleave(ptr, 4).reader().read_be32();
+        uint32_t gotdatachecksum = amigaChecksum(rawbytes.slice(56, 1024));
+
+        Bytes data;
+        data.writer().append(amigaDeinterleave(ptr, 512)).append(recoveryinfo);
+        _sector->data = data;
+        _sector->status = (gotdatachecksum == wanteddatachecksum)
+                              ? Sector::OK
+                              : Sector::BAD_CHECKSUM;
+    }
+
+private:
+    const AmigaDecoderProto& _config;
+    nanoseconds_t _clock;
+};
+
+std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new AmigaDecoder(config));
+}

arch/amiga/encoder.cc

@@ -0,0 +1,149 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "amiga.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "arch/amiga/amiga.pb.h"
+#include "lib/encoders/encoders.pb.h"
+
+static bool lastBit;
+
+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())
+            lastBit = bits[cursor++] = bit;
+    }
+}
+
+static void write_bits(
+    std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
+{
+    cursor += width;
+    lastBit = data & 1;
+    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_bits(
+    std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    BitReader bitr(br);
+
+    while (!bitr.eof())
+    {
+        if (cursor < bits.size())
+            bits[cursor++] = bitr.get();
+    }
+}
+
+static void write_sector(std::vector<bool>& bits,
+    unsigned& cursor,
+    const std::shared_ptr<const Sector>& sector)
+{
+    if ((sector->data.size() != 512) && (sector->data.size() != 528))
+        error("unsupported sector size --- you must pick 512 or 528");
+
+    uint32_t checksum = 0;
+
+    auto write_interleaved_bytes = [&](const Bytes& bytes)
+    {
+        Bytes interleaved = amigaInterleave(bytes);
+        Bytes mfm = encodeMfm(interleaved, lastBit);
+        checksum ^= amigaChecksum(mfm);
+        checksum &= 0x55555555;
+        write_bits(bits, cursor, mfm);
+    };
+
+    auto write_interleaved_word = [&](uint32_t word)
+    {
+        Bytes b(4);
+        b.writer().write_be32(word);
+        write_interleaved_bytes(b);
+    };
+
+    write_bits(bits, cursor, 0xaaaa, 2 * 8);
+    write_bits(bits, cursor, AMIGA_SECTOR_RECORD, 6 * 8);
+
+    checksum = 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(header);
+    Bytes recoveryInfo(16);
+    if (sector->data.size() == 528)
+        recoveryInfo = sector->data.slice(512, 16);
+    write_interleaved_bytes(recoveryInfo);
+    write_interleaved_word(checksum);
+
+    Bytes data = sector->data.slice(0, 512);
+    write_interleaved_word(
+        amigaChecksum(encodeMfm(amigaInterleave(data), lastBit)));
+    write_interleaved_bytes(data);
+}
+
+class AmigaEncoder : public Encoder
+{
+public:
+    AmigaEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.amiga())
+    {
+    }
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        /* Number of bits for one nominal revolution of a real 200ms Amiga disk.
+         */
+        int bitsPerRevolution = 200e3 / _config.clock_rate_us();
+        std::vector<bool> bits(bitsPerRevolution);
+        unsigned cursor = 0;
+
+        fillBitmapTo(bits,
+            cursor,
+            _config.post_index_gap_ms() * 1000 / _config.clock_rate_us(),
+            {true, false});
+        lastBit = false;
+
+        for (const auto& sector : sectors)
+            write_sector(bits, cursor, sector);
+
+        if (cursor >= bits.size())
+            error("track data overrun");
+        fillBitmapTo(bits, cursor, bits.size(), {true, false});
+
+        auto fluxmap = std::make_unique<Fluxmap>();
+        fluxmap->appendBits(bits,
+            calculatePhysicalClockPeriod(_config.clock_rate_us() * 1e3, 200e6));
+        return fluxmap;
+    }
+
+private:
+    const AmigaEncoderProto& _config;
+};
+
+std::unique_ptr<Encoder> createAmigaEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new AmigaEncoder(config));
+}

arch/apple2/apple2.h

@@ -0,0 +1,19 @@
+#ifndef APPLE2_H
+#define APPLE2_H
+
+#include <memory.h>
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+
+#define APPLE2_SECTOR_RECORD 0xd5aa96
+#define APPLE2_DATA_RECORD 0xd5aaad
+
+#define APPLE2_SECTOR_LENGTH 256
+#define APPLE2_ENCODED_SECTOR_LENGTH 342
+
+#define APPLE2_SECTORS 16
+
+extern std::unique_ptr<Decoder> createApple2Decoder(const DecoderProto& config);
+extern std::unique_ptr<Encoder> createApple2Encoder(const EncoderProto& config);
+
+#endif

arch/apple2/apple2.proto

@@ -0,0 +1,22 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message Apple2DecoderProto {
+	optional uint32 side_one_track_offset = 1
+		[ default = 0, (help) = "offset to apply to track numbers on side 1" ];
+}
+
+message Apple2EncoderProto
+{
+    /* 245kHz. */
+    optional double clock_period_us = 1
+        [ default = 4, (help) = "clock rate on the real device" ];
+    
+    /* Apple II disk drives spin at 300rpm. */
+    optional double rotational_period_ms = 2
+        [ default = 200.0, (help) = "rotational period on the real device" ];
+
+	optional uint32 side_one_track_offset = 3
+		[ default = 0, (help) = "offset to apply to track numbers on side 1" ];
+}

arch/apple2/decoder.cc

@@ -0,0 +1,175 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "apple2.h"
+#include "arch/apple2/apple2.pb.h"
+#include "lib/decoders/decoders.pb.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include <string.h>
+#include <algorithm>
+
+const FluxPattern SECTOR_RECORD_PATTERN(24, APPLE2_SECTOR_RECORD);
+const FluxPattern DATA_RECORD_PATTERN(24, APPLE2_DATA_RECORD);
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+
+static int decode_data_gcr(uint8_t gcr)
+{
+    switch (gcr)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+/* This is extremely inspired by the MESS implementation, written by Nathan
+ * Woods and R. Belmont:
+ * https://github.com/mamedev/mame/blob/7914a6083a3b3a8c243ae6c3b8cb50b023f21e0e/src/lib/formats/ap2_dsk.cpp
+ */
+static Bytes decode_crazy_data(const uint8_t* inp, Sector::Status& status)
+{
+    Bytes output(APPLE2_SECTOR_LENGTH);
+
+    uint8_t checksum = 0;
+    for (unsigned i = 0; i < APPLE2_ENCODED_SECTOR_LENGTH; i++)
+    {
+        checksum ^= decode_data_gcr(*inp++);
+
+        if (i >= 86)
+        {
+            /* 6 bit */
+            output[i - 86] |= (checksum << 2);
+        }
+        else
+        {
+            /* 3 * 2 bit */
+            output[i + 0] = ((checksum >> 1) & 0x01) | ((checksum << 1) & 0x02);
+            output[i + 86] =
+                ((checksum >> 3) & 0x01) | ((checksum >> 1) & 0x02);
+            if ((i + 172) < APPLE2_SECTOR_LENGTH)
+                output[i + 172] =
+                    ((checksum >> 5) & 0x01) | ((checksum >> 3) & 0x02);
+        }
+    }
+
+    checksum &= 0x3f;
+    uint8_t wantedchecksum = decode_data_gcr(*inp);
+    status = (checksum == wantedchecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    return output;
+}
+
+static uint8_t combine(uint16_t word)
+{
+    return word & (word >> 7);
+}
+
+class Apple2Decoder : public Decoder
+{
+public:
+    Apple2Decoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw24() != APPLE2_SECTOR_RECORD)
+            return;
+
+        /* Read header. */
+
+        auto header = toBytes(readRawBits(8 * 8)).slice(0, 8);
+        ByteReader br(header);
+
+        uint8_t volume = combine(br.read_be16());
+        _sector->logicalTrack = combine(br.read_be16());
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = combine(br.read_be16());
+        uint8_t checksum = combine(br.read_be16());
+
+        // If the checksum is correct, upgrade the sector from MISSING
+        // to DATA_MISSING in anticipation of its data record
+        if (checksum ==
+            (volume ^ _sector->logicalTrack ^ _sector->logicalSector))
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+
+        if (_sector->logicalSide == 1)
+            _sector->logicalTrack -= _config.apple2().side_one_track_offset();
+
+        /* Sanity check. */
+
+        if (_sector->logicalTrack > 100)
+        {
+            _sector->status = Sector::MISSING;
+            return;
+        }
+    }
+
+    void decodeDataRecord() override
+    {
+        /* Check ID. */
+
+        if (readRaw24() != APPLE2_DATA_RECORD)
+            return;
+
+        // Sometimes there's a 1-bit gap between APPLE2_DATA_RECORD and
+        // the data itself.  This has been seen on real world disks
+        // such as the Apple II Operating System Kit from Apple2Online.
+        // However, I haven't seen it described in any of the various
+        // references.
+        //
+        // This extra '0' bit would not affect the real disk interface,
+        // as it was a '1' reaching the top bit of a shift register
+        // that triggered a byte to be available, but it affects the
+        // way the data is read here.
+        //
+        // While the floppies tested only seemed to need this applied
+        // to the first byte of the data record, applying it
+        // consistently to all of them doesn't seem to hurt, and
+        // simplifies the code.
+
+        /* Read and decode data. */
+
+        auto readApple8 = [&]()
+        {
+            auto result = 0;
+            while ((result & 0x80) == 0)
+            {
+                auto b = readRawBits(1);
+                if (b.empty())
+                    break;
+                result = (result << 1) | b[0];
+            }
+            return result;
+        };
+
+        constexpr unsigned recordLength = APPLE2_ENCODED_SECTOR_LENGTH + 2;
+        uint8_t bytes[recordLength];
+        for (auto& byte : bytes)
+        {
+            byte = readApple8();
+        }
+
+        // Upgrade the sector from MISSING to BAD_CHECKSUM.
+        // If decode_crazy_data succeeds, it upgrades the sector to
+        // OK.
+        _sector->status = Sector::BAD_CHECKSUM;
+        _sector->data = decode_crazy_data(&bytes[0], _sector->status);
+    }
+};
+
+std::unique_ptr<Decoder> createApple2Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new Apple2Decoder(config));
+}

arch/apple2/encoder.cc

@@ -0,0 +1,192 @@
+#include "lib/globals.h"
+#include "arch/apple2/apple2.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/sector.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "fmt/format.h"
+#include "lib/encoders/encoders.pb.h"
+#include <ctype.h>
+#include "lib/bytes.h"
+
+static int encode_data_gcr(uint8_t data)
+{
+    switch (data)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case data:               \
+        return gcr;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+class Apple2Encoder : public Encoder
+{
+public:
+    Apple2Encoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.apple2())
+    {
+    }
+
+private:
+    const Apple2EncoderProto& _config;
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        int bitsPerRevolution =
+            (_config.rotational_period_ms() * 1e3) / _config.clock_period_us();
+
+        std::vector<bool> bits(bitsPerRevolution);
+        unsigned cursor = 0;
+
+        for (const auto& sector : sectors)
+            writeSector(bits, cursor, *sector);
+
+        if (cursor >= bits.size())
+            error("track data overrun by {} bits", cursor - bits.size());
+        fillBitmapTo(bits, cursor, bits.size(), {true, false});
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        fluxmap->appendBits(bits,
+            calculatePhysicalClockPeriod(_config.clock_period_us() * 1e3,
+                _config.rotational_period_ms() * 1e6));
+        return fluxmap;
+    }
+
+private:
+    uint8_t volume_id = 254;
+
+    /* This is extremely inspired by the MESS implementation, written by Nathan
+     * Woods and R. Belmont:
+     * https://github.com/mamedev/mame/blob/7914a6083a3b3a8c243ae6c3b8cb50b023f21e0e/src/lib/formats/ap2_dsk.cpp
+     * as well as Understanding the Apple II (1983) Chapter 9
+     * https://archive.org/details/Understanding_the_Apple_II_1983_Quality_Software/page/n230/mode/1up?view=theater
+     */
+
+    void writeSector(
+        std::vector<bool>& bits, unsigned& cursor, const Sector& sector) const
+    {
+        if ((sector.status == Sector::OK) or
+            (sector.status == Sector::BAD_CHECKSUM))
+        {
+            auto write_bit = [&](bool val)
+            {
+                if (cursor <= bits.size())
+                {
+                    bits[cursor] = val;
+                }
+                cursor++;
+            };
+
+            auto write_bits = [&](uint32_t bits, int width)
+            {
+                for (int i = width; i--;)
+                {
+                    write_bit(bits & (1u << i));
+                }
+            };
+
+            auto write_gcr44 = [&](uint8_t value)
+            {
+                write_bits((value << 7) | value | 0xaaaa, 16);
+            };
+
+            auto write_gcr6 = [&](uint8_t value)
+            {
+                write_bits(encode_data_gcr(value), 8);
+            };
+
+            // The special "FF40" sequence is used to synchronize the receiving
+            // shift register. It's written as "1111 1111 00"; FF indicates the
+            // 8 consecutive 1-bits, while "40" indicates the total number of
+            // microseconds.
+            auto write_ff40 = [&](int n = 1)
+            {
+                for (; n--;)
+                {
+                    write_bits(0xff << 2, 10);
+                }
+            };
+
+            // There is data to encode to disk.
+            if ((sector.data.size() != APPLE2_SECTOR_LENGTH))
+                error("unsupported sector size {} --- you must pick 256",
+                    sector.data.size());
+
+            // Write address syncing leader : A sequence of "FF40"s; 5 of them
+            // are said to suffice to synchronize the decoder.
+            // "FF40" indicates that the actual data written is "1111
+            // 1111 00" i.e., 8 1s and a total of 40 microseconds
+            //
+            // In standard formatting, the first logical sector apparently gets
+            // extra padding.
+            write_ff40(sector.logicalSector == 0 ? 32 : 8);
+
+            int track = sector.logicalTrack;
+            if (sector.logicalSide == 1)
+                track += _config.side_one_track_offset();
+
+            // Write address field: APPLE2_SECTOR_RECORD + sector identifier +
+            // DE AA EB
+            write_bits(APPLE2_SECTOR_RECORD, 24);
+            write_gcr44(volume_id);
+            write_gcr44(track);
+            write_gcr44(sector.logicalSector);
+            write_gcr44(volume_id ^ track ^ sector.logicalSector);
+            write_bits(0xDEAAEB, 24);
+
+            // Write data syncing leader: FF40 + APPLE2_DATA_RECORD + sector
+            // data + sum + DE AA EB (+ mystery bits cut off of the scan?)
+            write_ff40(8);
+            write_bits(APPLE2_DATA_RECORD, 24);
+
+            // Convert the sector data to GCR, append the checksum, and write it
+            // out
+            constexpr auto TWOBIT_COUNT =
+                0x56; // Size of the 'twobit' area at the start of the GCR data
+            uint8_t checksum = 0;
+            for (int i = 0; i < APPLE2_ENCODED_SECTOR_LENGTH; i++)
+            {
+                int value;
+                if (i >= TWOBIT_COUNT)
+                {
+                    value = sector.data[i - TWOBIT_COUNT] >> 2;
+                }
+                else
+                {
+                    uint8_t tmp = sector.data[i];
+                    value = ((tmp & 1) << 1) | ((tmp & 2) >> 1);
+
+                    tmp = sector.data[i + TWOBIT_COUNT];
+                    value |= ((tmp & 1) << 3) | ((tmp & 2) << 1);
+
+                    if (i + 2 * TWOBIT_COUNT < APPLE2_SECTOR_LENGTH)
+                    {
+                        tmp = sector.data[i + 2 * TWOBIT_COUNT];
+                        value |= ((tmp & 1) << 5) | ((tmp & 2) << 3);
+                    }
+                }
+                checksum ^= value;
+                // assert(checksum & ~0x3f == 0);
+                write_gcr6(checksum);
+                checksum = value;
+            }
+            if (sector.status == Sector::BAD_CHECKSUM)
+                checksum ^= 0x3f;
+            write_gcr6(checksum);
+            write_bits(0xDEAAEB, 24);
+        }
+    }
+};
+
+std::unique_ptr<Encoder> createApple2Encoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new Apple2Encoder(config));
+}

arch/brother/brother.h

@@ -0,0 +1,21 @@
+#ifndef BROTHER_H
+#define BROTHER_H
+
+/* Brother word processor format (or at least, one of them) */
+
+#define BROTHER_SECTOR_RECORD 0xFFFFFD57
+#define BROTHER_DATA_RECORD 0xFFFFFDDB
+#define BROTHER_DATA_RECORD_PAYLOAD 256
+#define BROTHER_DATA_RECORD_CHECKSUM 3
+#define BROTHER_DATA_RECORD_ENCODED_SIZE 415
+
+#define BROTHER_TRACKS_PER_240KB_DISK 78
+#define BROTHER_TRACKS_PER_120KB_DISK 39
+#define BROTHER_SECTORS_PER_TRACK 12
+
+extern std::unique_ptr<Decoder> createBrotherDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createBrotherEncoder(
+    const EncoderProto& config);
+
+#endif

arch/brother/brother.proto

@@ -0,0 +1,18 @@
+syntax = "proto2";
+
+message BrotherDecoderProto {}
+
+enum BrotherFormat {
+	BROTHER240 = 0;
+	BROTHER120 = 1;
+};
+
+message BrotherEncoderProto {
+	optional double clock_rate_us = 1 [default = 3.83];
+	optional double post_index_gap_ms = 2 [default = 1.0];
+	optional double sector_spacing_ms = 3 [default = 16.2];
+	optional double post_header_spacing_ms = 4 [default = 0.69];
+
+	optional BrotherFormat format = 6 [default = BROTHER240];
+}
+

arch/brother/data_gcr.h

@@ -1,13 +1,13 @@
-GCR_ENTRY(0x55, 0) // 00000
-GCR_ENTRY(0x57, 1) // 00001
-GCR_ENTRY(0x5b, 2) // 00010
-GCR_ENTRY(0x5d, 3) // 00011
-GCR_ENTRY(0x5f, 4) // 00100 
-GCR_ENTRY(0x6b, 5) // 00101
-GCR_ENTRY(0x6d, 6) // 00110
-GCR_ENTRY(0x6f, 7) // 00111
-GCR_ENTRY(0x75, 8) // 01000
-GCR_ENTRY(0x77, 9) // 01001
+GCR_ENTRY(0x55, 0)  // 00000
+GCR_ENTRY(0x57, 1)  // 00001
+GCR_ENTRY(0x5b, 2)  // 00010
+GCR_ENTRY(0x5d, 3)  // 00011
+GCR_ENTRY(0x5f, 4)  // 00100
+GCR_ENTRY(0x6b, 5)  // 00101
+GCR_ENTRY(0x6d, 6)  // 00110
+GCR_ENTRY(0x6f, 7)  // 00111
+GCR_ENTRY(0x75, 8)  // 01000
+GCR_ENTRY(0x77, 9)  // 01001
 GCR_ENTRY(0x7b, 10) // 01010
 GCR_ENTRY(0x7d, 11) // 01011
 GCR_ENTRY(0x7f, 12) // 01100
@@ -30,4 +30,3 @@ GCR_ENTRY(0xef, 28) // 11100
 GCR_ENTRY(0xf5, 29) // 11101
 GCR_ENTRY(0xf7, 30) // 11110
 GCR_ENTRY(0xfb, 31) // 11111
-

arch/brother/decoder.cc

@@ -0,0 +1,121 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "brother.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "lib/crc.h"
+#include <ctype.h>
+
+const FluxPattern SECTOR_RECORD_PATTERN(32, BROTHER_SECTOR_RECORD);
+const FluxPattern DATA_RECORD_PATTERN(32, BROTHER_DATA_RECORD);
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+
+static std::vector<uint8_t> outputbuffer;
+
+/*
+ * Brother disks have this very very non-IBM system where sector header records
+ * and data records use two different kinds of GCR: sector headers are 8-in-16
+ * (but the encodable values range from 0 to 77ish only) and data headers are
+ * 5-in-8. In addition, there's a non-encoded 10-bit ID word at the beginning
+ * of each record, as well as a string of 53 1s introducing them. That does at
+ * least make them easy to find.
+ *
+ * Disk formats vary from machine to machine, but mine uses 78 tracks. Track 0
+ * is erased but not formatted.  Track alignment is extremely dubious and
+ * Brother track 0 shows up on my machine at track 2.
+ */
+
+static int decode_data_gcr(uint8_t gcr)
+{
+    switch (gcr)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+static int decode_header_gcr(uint16_t word)
+{
+    switch (word)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "header_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+class BrotherDecoder : public Decoder
+{
+public:
+    BrotherDecoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw32() != BROTHER_SECTOR_RECORD)
+            return;
+
+        const auto& rawbits = readRawBits(32);
+        const auto& bytes = toBytes(rawbits).slice(0, 4);
+
+        ByteReader br(bytes);
+        _sector->logicalTrack = decode_header_gcr(br.read_be16());
+        _sector->logicalSector = decode_header_gcr(br.read_be16());
+
+        /* Sanity check the values read; there's no header checksum and
+         * occasionally we get garbage due to bit errors. */
+        if (_sector->logicalSector > 11)
+            return;
+        if (_sector->logicalTrack > 79)
+            return;
+
+        _sector->status = Sector::DATA_MISSING;
+    }
+
+    void decodeDataRecord() override
+    {
+        if (readRaw32() != BROTHER_DATA_RECORD)
+            return;
+
+        const auto& rawbits = readRawBits(BROTHER_DATA_RECORD_ENCODED_SIZE * 8);
+        const auto& rawbytes =
+            toBytes(rawbits).slice(0, BROTHER_DATA_RECORD_ENCODED_SIZE);
+
+        Bytes bytes;
+        ByteWriter bw(bytes);
+        BitWriter bitw(bw);
+        for (uint8_t b : rawbytes)
+        {
+            uint32_t nibble = decode_data_gcr(b);
+            bitw.push(nibble, 5);
+        }
+        bitw.flush();
+
+        _sector->data = bytes.slice(0, BROTHER_DATA_RECORD_PAYLOAD);
+        uint32_t realCrc = crcbrother(_sector->data);
+        uint32_t wantCrc =
+            bytes.reader().seek(BROTHER_DATA_RECORD_PAYLOAD).read_be24();
+        _sector->status =
+            (realCrc == wantCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createBrotherDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new BrotherDecoder(config));
+}

arch/brother/encoder.cc

@@ -0,0 +1,154 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "brother.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "arch/brother/brother.pb.h"
+#include "lib/encoders/encoders.pb.h"
+
+static int encode_header_gcr(uint16_t word)
+{
+    switch (word)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case data:               \
+        return gcr;
+#include "header_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+static int encode_data_gcr(uint8_t data)
+{
+    switch (data)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case data:               \
+        return gcr;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+static void write_bits(
+    std::vector<bool>& bits, unsigned& cursor, uint32_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_sector_header(
+    std::vector<bool>& bits, unsigned& cursor, int track, int sector)
+{
+    write_bits(bits, cursor, 0xffffffff, 31);
+    write_bits(bits, cursor, BROTHER_SECTOR_RECORD, 32);
+    write_bits(bits, cursor, encode_header_gcr(track), 16);
+    write_bits(bits, cursor, encode_header_gcr(sector), 16);
+    write_bits(bits, cursor, encode_header_gcr(0x2f), 16);
+}
+
+static void write_sector_data(
+    std::vector<bool>& bits, unsigned& cursor, const Bytes& data)
+{
+    write_bits(bits, cursor, 0xffffffff, 32);
+    write_bits(bits, cursor, BROTHER_DATA_RECORD, 32);
+
+    uint16_t fifo = 0;
+    int width = 0;
+
+    if (data.size() != BROTHER_DATA_RECORD_PAYLOAD)
+        error("unsupported sector size");
+
+    auto write_byte = [&](uint8_t byte)
+    {
+        fifo |= (byte << (8 - width));
+        width += 8;
+
+        while (width >= 5)
+        {
+            uint8_t quintet = fifo >> 11;
+            fifo <<= 5;
+            width -= 5;
+
+            write_bits(bits, cursor, encode_data_gcr(quintet), 8);
+        }
+    };
+
+    for (uint8_t byte : data)
+        write_byte(byte);
+
+    uint32_t realCrc = crcbrother(data);
+    write_byte(realCrc >> 16);
+    write_byte(realCrc >> 8);
+    write_byte(realCrc);
+    write_byte(0x58); /* magic */
+    write_byte(0xd4);
+    while (width != 0)
+        write_byte(0);
+}
+
+class BrotherEncoder : public Encoder
+{
+public:
+    BrotherEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.brother())
+    {
+    }
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        int bitsPerRevolution = 200000.0 / _config.clock_rate_us();
+        std::vector<bool> bits(bitsPerRevolution);
+        unsigned cursor = 0;
+
+        int sectorCount = 0;
+        for (const auto& sectorData : sectors)
+        {
+            double headerMs = _config.post_index_gap_ms() +
+                              sectorCount * _config.sector_spacing_ms();
+            unsigned headerCursor = headerMs * 1e3 / _config.clock_rate_us();
+            double dataMs = headerMs + _config.post_header_spacing_ms();
+            unsigned dataCursor = dataMs * 1e3 / _config.clock_rate_us();
+
+            fillBitmapTo(bits, cursor, headerCursor, {true, false});
+            write_sector_header(bits,
+                cursor,
+                sectorData->logicalTrack,
+                sectorData->logicalSector);
+            fillBitmapTo(bits, cursor, dataCursor, {true, false});
+            write_sector_data(bits, cursor, sectorData->data);
+
+            sectorCount++;
+        }
+
+        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, _config.clock_rate_us() * 1e3);
+        return fluxmap;
+    }
+
+private:
+    const BrotherEncoderProto& _config;
+};
+
+std::unique_ptr<Encoder> createBrotherEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new BrotherEncoder(config));
+}

arch/brother/header_gcr.h

@@ -76,4 +76,3 @@ GCR_ENTRY(0x6BAB, 74)
 GCR_ENTRY(0xAD5F, 75)
 GCR_ENTRY(0xDBED, 76)
 GCR_ENTRY(0x55BB, 77)
-

arch/build.py

@@ -0,0 +1,27 @@
+from build.c import cxxlibrary
+from build.protobuf import proto, protocc
+
+proto(
+    name="arch_proto",
+    srcs=[
+        "./aeslanier/aeslanier.proto",
+        "./agat/agat.proto",
+        "./amiga/amiga.proto",
+        "./apple2/apple2.proto",
+        "./brother/brother.proto",
+        "./c64/c64.proto",
+        "./f85/f85.proto",
+        "./fb100/fb100.proto",
+        "./ibm/ibm.proto",
+        "./macintosh/macintosh.proto",
+        "./micropolis/micropolis.proto",
+        "./mx/mx.proto",
+        "./northstar/northstar.proto",
+        "./rolandd20/rolandd20.proto",
+        "./smaky6/smaky6.proto",
+        "./tartu/tartu.proto",
+        "./tids990/tids990.proto",
+        "./victor9k/victor9k.proto",
+        "./zilogmcz/zilogmcz.proto",
+    ],
+)

arch/c64/c64.cc

@@ -0,0 +1,28 @@
+#include "lib/globals.h"
+#include "c64.h"
+
+/*
+ *   Track   Sectors/track   # Sectors   Storage in Bytes   Clock rate
+ *   -----   -------------   ---------   ----------------   ----------
+ *    1-17        21            357           7820             3.25
+ *   18-24        19            133           7170             3.5
+ *   25-30        18            108           6300             3.75
+ *   31-40(*)     17             85           6020             4
+ *                              ---
+ *                              683 (for a 35 track image)
+ *
+ * The clock rate is normalised for a 200ms drive.
+ */
+
+nanoseconds_t clockPeriodForC64Track(unsigned track)
+{
+    constexpr double b = 8.0;
+
+    if (track < 17)
+        return 26.0 / b;
+    if (track < 24)
+        return 28.0 / b;
+    if (track < 30)
+        return 30.0 / b;
+    return 32.0 / b;
+}

arch/c64/c64.h

@@ -0,0 +1,37 @@
+#ifndef C64_H
+#define C64_H
+
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+
+#define C64_SECTOR_RECORD 0xffd49
+#define C64_DATA_RECORD 0xffd57
+#define C64_SECTOR_LENGTH 256
+
+/* Source: http://www.unusedino.de/ec64/technical/formats/g64.html
+   1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
+   2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
+   3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
+   4. Data sync         FF FF FF FF FF (40 'on' bits, not GCR)
+   5. Data block        55...4A (325 GCR bytes)
+   6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
+   1. Header sync       (SYNC for the next sector)
+*/
+#define C64_HEADER_DATA_SYNC 0xFF
+#define C64_HEADER_BLOCK_ID 0x08
+#define C64_DATA_BLOCK_ID 0x07
+#define C64_HEADER_GAP 0x55
+#define C64_INTER_SECTOR_GAP 0x55
+#define C64_PADDING 0x0F
+
+#define C64_TRACKS_PER_DISK 40
+#define C64_BAM_TRACK 17
+
+extern std::unique_ptr<Decoder> createCommodore64Decoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createCommodore64Encoder(
+    const EncoderProto& config);
+
+extern nanoseconds_t clockPeriodForC64Track(unsigned track);
+
+#endif

arch/c64/c64.proto

@@ -0,0 +1,11 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message Commodore64DecoderProto {}
+
+message Commodore64EncoderProto {
+	optional double post_index_gap_us = 1 [default=0.0,
+		(help) = "post-index gap before first sector header."];
+}
+

arch/c64/decoder.cc

@@ -0,0 +1,102 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "c64.h"
+#include "lib/crc.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include <string.h>
+#include <algorithm>
+
+const FluxPattern SECTOR_RECORD_PATTERN(20, C64_SECTOR_RECORD);
+const FluxPattern DATA_RECORD_PATTERN(20, C64_DATA_RECORD);
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+
+static int decode_data_gcr(uint8_t gcr)
+{
+    switch (gcr)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+static Bytes decode(const std::vector<bool>& bits)
+{
+    Bytes output;
+    ByteWriter bw(output);
+    BitWriter bitw(bw);
+
+    auto ii = bits.begin();
+    while (ii != bits.end())
+    {
+        uint8_t inputfifo = 0;
+        for (size_t i = 0; i < 5; i++)
+        {
+            if (ii == bits.end())
+                break;
+            inputfifo = (inputfifo << 1) | *ii++;
+        }
+
+        bitw.push(decode_data_gcr(inputfifo), 4);
+    }
+    bitw.flush();
+
+    return output;
+}
+
+class Commodore64Decoder : public Decoder
+{
+public:
+    Commodore64Decoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw20() != C64_SECTOR_RECORD)
+            return;
+
+        const auto& bits = readRawBits(5 * 10);
+        const auto& bytes = decode(bits).slice(0, 5);
+
+        uint8_t checksum = bytes[0];
+        _sector->logicalSector = bytes[1];
+        _sector->logicalSide = 0;
+        _sector->logicalTrack = bytes[2] - 1;
+        if (checksum == xorBytes(bytes.slice(1, 4)))
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+    }
+
+    void decodeDataRecord() override
+    {
+        if (readRaw20() != C64_DATA_RECORD)
+            return;
+
+        const auto& bits = readRawBits(259 * 10);
+        const auto& bytes = decode(bits).slice(0, 259);
+
+        _sector->data = bytes.slice(0, C64_SECTOR_LENGTH);
+        uint8_t gotChecksum = xorBytes(_sector->data);
+        uint8_t wantChecksum = bytes[256];
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createCommodore64Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new Commodore64Decoder(config));
+}

arch/c64/encoder.cc

@@ -0,0 +1,318 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "c64.h"
+#include "lib/crc.h"
+#include "lib/sector.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "fmt/format.h"
+#include "arch/c64/c64.pb.h"
+#include "lib/encoders/encoders.pb.h"
+#include "lib/layout.h"
+#include <ctype.h>
+#include "lib/bytes.h"
+
+static bool lastBit;
+
+static int encode_data_gcr(uint8_t data)
+{
+    switch (data)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case data:               \
+        return gcr;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+static void write_bits(
+    std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
+{
+    for (bool bit : src) // Range-based for loop
+    {
+        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 std::vector<bool> encode_data(uint8_t input)
+{
+    /*
+     * Four 8-bit data bytes are converted to four 10-bit GCR bytes at a time by
+     * the 1541 DOS.  RAM is only an 8-bit storage device though. This hardware
+     * limitation prevents a 10-bit GCR byte from being stored in a single
+     * memory location. Four 10-bit GCR bytes total 40 bits - a number evenly
+     * divisible by our overriding 8-bit constraint. Commodore sub- divides the
+     * 40 GCR bits into five 8-bit bytes to solve this dilemma. This explains
+     * why four 8-bit data bytes are converted to GCR form at a time. The
+     * following step by step example demonstrates how this bit manipulation is
+     * performed by the DOS.
+     *
+     * STEP 1. Four 8-bit Data Bytes
+     * $08 $10 $00 $12
+     *
+     * STEP 2. Hexadecimal to Binary Conversion
+     * 1. Binary Equivalents
+     * $08       $10         $00         $12
+     * 00001000  00010000    00000000    00010010
+     *
+     * STEP 3. Binary to GCR Conversion
+     * 1. Four 8-bit Data Bytes
+     * 00001000 00010000 00000000 00010010
+     * 2. High and Low Nybbles
+     * 0000 1000 0001 0000 0000 0000 0001 0010
+     * 3. High and Low Nybble GCR Equivalents
+     * 01010 01001 01011 01010 01010 01010 01011 10010
+     * 4. Four 10-bit GCR Bytes
+     * 0101001001 0101101010 0101001010 0101110010
+     *
+     * STEP 4. 10-bit GCR to 8-bit GCR Conversion
+     *   1. Concatenate Four 10-bit GCR Bytes
+     *   0101001001010110101001010010100101110010
+     *   2. Five 8-bit Subdivisions
+     *   01010010 01010110 10100101 00101001 01110010
+     *
+     * STEP 5. Binary to Hexadecimal Conversion
+     * 1. Hexadecimal Equivalents
+     *   01010010    01010110    10100101    00101001    01110010
+     *   $52         $56         $A5         $29         $72
+     *
+     * STEP 6. Four 8-bit Data Bytes are Recorded as Five 8-bit GCR Bytes
+     *   $08 $10 $00 $12
+     *
+     * are recorded as
+     *   $52 $56 $A5 $29 $72
+     */
+
+    std::vector<bool> output(10, false);
+    uint8_t hi = 0;
+    uint8_t lo = 0;
+    uint8_t lo_GCR = 0;
+    uint8_t hi_GCR = 0;
+
+    // Convert the byte in high and low nibble
+    lo = input >> 4; // get the lo nibble shift the bits 4 to the right
+    hi = input & 15; // get the hi nibble bij masking the lo bits (00001111)
+
+    lo_GCR = encode_data_gcr(lo); // example value: 0000   GCR = 01010
+    hi_GCR = encode_data_gcr(hi); // example value: 1000   GCR = 01001
+    // output = [0,1,2,3,4,5,6,7,8,9]
+    // value  = [0,1,0,1,0,0,1,0,0,1]
+    //           01010 01001
+
+    int b = 4;
+    for (int i = 0; i < 10; i++)
+    {
+        if (i < 5)                        // 01234
+        {                                 // i = 0 op
+            output[4 - i] = (lo_GCR & 1); // 01010
+
+            // 01010 -> & 00001 -> 00000 output[4] = 0
+            // 00101 -> & 00001 -> 00001 output[3] = 1
+            // 00010 -> & 00001 -> 00000 output[2] = 0
+            // 00001 -> & 00001 -> 00001 output[1] = 1
+            // 00000 -> & 00001 -> 00000 output[0] = 0
+            lo_GCR >>= 1;
+        }
+        else
+        {
+            output[i + b] = (hi_GCR & 1); // 01001
+            // 01001 -> & 00001 -> 00001 output[9] = 1
+            // 00100 -> & 00001 -> 00000 output[8] = 0
+            // 00010 -> & 00001 -> 00000 output[7] = 0
+            // 00001 -> & 00001 -> 00001 output[6] = 1
+            // 00000 -> & 00001 -> 00000 output[5] = 0
+            hi_GCR >>= 1;
+            b = b - 2;
+        }
+    }
+    return output;
+}
+
+class Commodore64Encoder : public Encoder
+{
+public:
+    Commodore64Encoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.c64())
+    {
+    }
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        /* The format ID Character # 1 and # 2 are in the .d64 image only
+         * present in track 18 sector zero which contains the BAM info in byte
+         * 162 and 163. it is written in every header of every sector and track.
+         * headers are not stored in a d64 disk image so we have to get it from
+         * track 18 which contains the BAM.
+         */
+
+        const auto& sectorData = image.get(
+            C64_BAM_TRACK, 0, 0); // Read de BAM to get the DISK ID bytes
+        if (sectorData)
+        {
+            ByteReader br(sectorData->data);
+            br.seek(162); // goto position of the first Disk ID Byte
+            _formatByte1 = br.read_8();
+            _formatByte2 = br.read_8();
+        }
+        else
+            _formatByte1 = _formatByte2 = 0;
+
+        double clockRateUs = clockPeriodForC64Track(trackInfo->logicalTrack);
+        int bitsPerRevolution = 200000.0 / clockRateUs;
+
+        std::vector<bool> bits(bitsPerRevolution);
+        unsigned cursor = 0;
+
+        fillBitmapTo(bits,
+            cursor,
+            _config.post_index_gap_us() / clockRateUs,
+            {true, false});
+        lastBit = false;
+
+        for (const auto& sector : sectors)
+            writeSector(bits, cursor, sector);
+
+        if (cursor >= bits.size())
+            error("track data overrun by {} bits", cursor - bits.size());
+        fillBitmapTo(bits, cursor, bits.size(), {true, false});
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        fluxmap->appendBits(
+            bits, calculatePhysicalClockPeriod(clockRateUs * 1e3, 200e6));
+        return fluxmap;
+    }
+
+private:
+    void writeSector(std::vector<bool>& bits,
+        unsigned& cursor,
+        std::shared_ptr<const Sector> sector) const
+    {
+        /* Source: http://www.unusedino.de/ec64/technical/formats/g64.html
+         * 1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
+         * 2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
+         * 3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
+         * 4. Data sync         FF FF FF FF FF (40 'on' bits, not GCR)
+         * 5. Data block        55...4A (325 GCR bytes)
+         * 6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
+         * 1. Header sync       (SYNC for the next sector)
+         */
+        if ((sector->status == Sector::OK) or
+            (sector->status == Sector::BAD_CHECKSUM))
+        {
+            // There is data to encode to disk.
+            if ((sector->data.size() != C64_SECTOR_LENGTH))
+                error("unsupported sector size {} --- you must pick 256",
+                    sector->data.size());
+
+            // 1. Write header Sync (not GCR)
+            for (int i = 0; i < 6; i++)
+                write_bits(
+                    bits, cursor, C64_HEADER_DATA_SYNC, 1 * 8); /* sync */
+
+            // 2. Write Header info 10 GCR bytes
+            /*
+             * The 10 byte header info (#2) is GCR encoded and must be decoded
+             * to it's normal 8 bytes to be understood. Once decoded, its
+             * breakdown is as follows:
+             *
+             * Byte $00 - header block ID           ($08)
+             *   01 - header block checksum 16  (EOR of $02-$05)
+             *   02 - Sector
+             *   03 - Track
+             *   04 - Format ID byte #2
+             *   05 - Format ID byte #1
+             *   06-07 - $0F ("off" bytes)
+             */
+            uint8_t encodedTrack =
+                ((sector->logicalTrack) +
+                    1); // C64 track numbering starts with 1. Fluxengine with 0.
+            uint8_t encodedSector = sector->logicalSector;
+            // uint8_t formatByte1 = C64_FORMAT_ID_BYTE1;
+            // uint8_t formatByte2 = C64_FORMAT_ID_BYTE2;
+            uint8_t headerChecksum =
+                (encodedTrack ^ encodedSector ^ _formatByte1 ^ _formatByte2);
+            write_bits(bits, cursor, encode_data(C64_HEADER_BLOCK_ID));
+            write_bits(bits, cursor, encode_data(headerChecksum));
+            write_bits(bits, cursor, encode_data(encodedSector));
+            write_bits(bits, cursor, encode_data(encodedTrack));
+            write_bits(bits, cursor, encode_data(_formatByte2));
+            write_bits(bits, cursor, encode_data(_formatByte1));
+            write_bits(bits, cursor, encode_data(C64_PADDING));
+            write_bits(bits, cursor, encode_data(C64_PADDING));
+
+            // 3. Write header GAP not GCR
+            for (int i = 0; i < 9; i++)
+                write_bits(
+                    bits, cursor, C64_HEADER_GAP, 1 * 8); /* header gap */
+
+            // 4. Write Data sync not GCR
+            for (int i = 0; i < 6; i++)
+                write_bits(
+                    bits, cursor, C64_HEADER_DATA_SYNC, 1 * 8); /* sync */
+
+            // 5. Write data block 325 GCR bytes
+            /*
+             * The 325 byte data block (#5) is GCR encoded and must be  decoded
+             * to  its normal 260 bytes to be understood. The data block is made
+             * up of the following:
+             *
+             * Byte    $00 - data block ID ($07)
+             *      01-100 - 256 bytes data
+             *      101 - data block checksum (EOR of $01-100)
+             *      102-103 - $00 ("off" bytes, to make the sector size a
+             * multiple of 5)
+             */
+
+            write_bits(bits, cursor, encode_data(C64_DATA_BLOCK_ID));
+            uint8_t dataChecksum = xorBytes(sector->data);
+            ByteReader br(sector->data);
+            int i = 0;
+            for (i = 0; i < C64_SECTOR_LENGTH; i++)
+            {
+                uint8_t val = br.read_8();
+                write_bits(bits, cursor, encode_data(val));
+            }
+            write_bits(bits, cursor, encode_data(dataChecksum));
+            write_bits(bits, cursor, encode_data(C64_PADDING));
+            write_bits(bits, cursor, encode_data(C64_PADDING));
+
+            // 6. Write inter-sector gap 9 - 12 bytes nor gcr
+            for (int i = 0; i < 9; i++)
+                write_bits(
+                    bits, cursor, C64_INTER_SECTOR_GAP, 1 * 8); /* sync */
+        }
+    }
+
+private:
+    const Commodore64EncoderProto& _config;
+    uint8_t _formatByte1;
+    uint8_t _formatByte2;
+};
+
+std::unique_ptr<Encoder> createCommodore64Encoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new Commodore64Encoder(config));
+}
+
+// vim: sw=4 ts=4 et

arch/f85/decoder.cc

@@ -0,0 +1,110 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "f85.h"
+#include "lib/crc.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include <string.h>
+#include <algorithm>
+
+const FluxPattern SECTOR_RECORD_PATTERN(24, F85_SECTOR_RECORD);
+const FluxPattern DATA_RECORD_PATTERN(24, F85_DATA_RECORD);
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+
+static int decode_data_gcr(uint8_t gcr)
+{
+    switch (gcr)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+static Bytes decode(const std::vector<bool>& bits)
+{
+    Bytes output;
+    ByteWriter bw(output);
+    BitWriter bitw(bw);
+
+    auto ii = bits.begin();
+    while (ii != bits.end())
+    {
+        uint8_t inputfifo = 0;
+        for (size_t i = 0; i < 5; i++)
+        {
+            if (ii == bits.end())
+                break;
+            inputfifo = (inputfifo << 1) | *ii++;
+        }
+
+        bitw.push(decode_data_gcr(inputfifo), 4);
+    }
+    bitw.flush();
+
+    return output;
+}
+
+class DurangoF85Decoder : public Decoder
+{
+public:
+    DurangoF85Decoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        /* Skip sync bits and ID byte. */
+
+        if (readRaw24() != F85_SECTOR_RECORD)
+            return;
+
+        /* Read header. */
+
+        const auto& bytes = decode(readRawBits(6 * 10));
+
+        _sector->logicalSector = bytes[2];
+        _sector->logicalSide = 0;
+        _sector->logicalTrack = bytes[0];
+
+        uint16_t wantChecksum = bytes.reader().seek(4).read_be16();
+        uint16_t gotChecksum = crc16(CCITT_POLY, 0xef21, bytes.slice(0, 4));
+        if (wantChecksum == gotChecksum)
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+    }
+
+    void decodeDataRecord() override
+    {
+        /* Skip sync bits ID byte. */
+
+        if (readRaw24() != F85_DATA_RECORD)
+            return;
+
+        const auto& bytes = decode(readRawBits((F85_SECTOR_LENGTH + 3) * 10))
+                                .slice(0, F85_SECTOR_LENGTH + 3);
+        ByteReader br(bytes);
+
+        _sector->data = br.read(F85_SECTOR_LENGTH);
+        uint16_t wantChecksum = br.read_be16();
+        uint16_t gotChecksum = crc16(CCITT_POLY, 0xbf84, _sector->data);
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createDurangoF85Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new DurangoF85Decoder(config));
+}

arch/f85/f85.h

@@ -0,0 +1,11 @@
+#ifndef F85_H
+#define F85_H
+
+#define F85_SECTOR_RECORD 0xffffce /* 1111 1111 1111 1111 1100 1110 */
+#define F85_DATA_RECORD 0xffffcb   /* 1111 1111 1111 1111 1100 1101 */
+#define F85_SECTOR_LENGTH 512
+
+extern std::unique_ptr<Decoder> createDurangoF85Decoder(
+    const DecoderProto& config);
+
+#endif

arch/f85/f85.proto

@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message F85DecoderProto {}
+

arch/fb100/decoder.cc

@@ -0,0 +1,142 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "fb100.h"
+#include "lib/crc.h"
+#include "lib/bytes.h"
+#include "lib/decoders/rawbits.h"
+#include "fmt/format.h"
+#include <string.h>
+#include <algorithm>
+
+const FluxPattern SECTOR_ID_PATTERN(16, 0xabaa);
+
+/*
+ * Reverse engineered from a dump of the floppy drive's ROM. I have no idea how
+ * it works.
+ *
+ * LF8BA:
+ *         clra
+ *         staa    X00B0
+ *         staa    X00B1
+ *         ldx     #$8000
+ * LF8C2:  ldaa    $00,x
+ *         inx
+ *         bsr     LF8CF
+ *         cpx     #$8011
+ *         bne     LF8C2
+ *         ldd     X00B0
+ *         rts
+ * LF8CF:
+ *         eora    X00B0
+ *         staa    X00CF
+ *         asla
+ *         asla
+ *         asla
+ *         asla
+ *         eora    X00CF
+ *         staa    X00CF
+ *         rola
+ *         rola
+ *         rola
+ *         tab
+ *         anda    #$F8
+ *         eora    X00B1
+ *         staa    X00B0
+ *         rolb
+ *         rolb
+ *         andb    #$0F
+ *         eorb    X00B0
+ *         stab    X00B0
+ *         rolb
+ *         eorb    X00CF
+ *         stab    X00B1
+ *         rts
+ */
+
+static void rol(uint8_t& b, bool& c)
+{
+    bool newc = b & 0x80;
+    b <<= 1;
+    b |= c;
+    c = newc;
+}
+
+static uint16_t checksum(const Bytes& bytes)
+{
+    uint8_t crclo = 0;
+    uint8_t crchi = 0;
+    for (uint8_t a : bytes)
+    {
+        a ^= crchi;
+        uint8_t t1 = a;
+        a <<= 4;
+        bool c = a & 0x10;
+        a ^= t1;
+        t1 = a;
+        rol(a, c);
+        rol(a, c);
+        rol(a, c);
+        uint8_t b = a;
+        a &= 0xf8;
+        a ^= crclo;
+        crchi = a;
+        rol(b, c);
+        rol(b, c);
+        b &= 0x0f;
+        b ^= crchi;
+        crchi = b;
+        rol(b, c);
+        b ^= t1;
+        crclo = b;
+    }
+
+    return (crchi << 8) | crclo;
+}
+
+class Fb100Decoder : public Decoder
+{
+public:
+    Fb100Decoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(SECTOR_ID_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        auto rawbits = readRawBits(FB100_RECORD_SIZE * 16);
+
+        const Bytes bytes = decodeFmMfm(rawbits).slice(0, FB100_RECORD_SIZE);
+        ByteReader br(bytes);
+        br.seek(1);
+        const Bytes id = br.read(FB100_ID_SIZE);
+        uint16_t wantIdCrc = br.read_be16();
+        uint16_t gotIdCrc = checksum(id);
+        const Bytes payload = br.read(FB100_PAYLOAD_SIZE);
+        uint16_t wantPayloadCrc = br.read_be16();
+        uint16_t gotPayloadCrc = checksum(payload);
+
+        if (wantIdCrc != gotIdCrc)
+            return;
+
+        uint8_t abssector = id[2];
+        _sector->logicalTrack = abssector >> 1;
+        _sector->logicalSide = 0;
+        _sector->logicalSector = abssector & 1;
+        _sector->data.writer().append(id.slice(5, 12)).append(payload);
+
+        _sector->status = (wantPayloadCrc == gotPayloadCrc)
+                              ? Sector::OK
+                              : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new Fb100Decoder(config));
+}

arch/fb100/fb100.h

@@ -0,0 +1,10 @@
+#ifndef FB100_H
+#define FB100_H
+
+#define FB100_RECORD_SIZE 0x516 /* bytes */
+#define FB100_ID_SIZE 17
+#define FB100_PAYLOAD_SIZE 0x500
+
+extern std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config);
+
+#endif

arch/fb100/fb100.proto

@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message Fb100DecoderProto {}
+

arch/ibm/decoder.cc

@@ -0,0 +1,250 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "ibm.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include "arch/ibm/ibm.pb.h"
+#include "lib/proto.h"
+#include "lib/layout.h"
+#include <string.h>
+
+static_assert(std::is_trivially_copyable<IbmIdam>::value,
+    "IbmIdam is not trivially copyable");
+
+/*
+ * The markers at the beginning of records are special, and have
+ * missing clock pulses, allowing them to be found by the logic.
+ *
+ * IAM record:
+ * flux:   XXXX-XXX-XXXX-X- = 0xf77a
+ * clock:  X X - X - X X X  = 0xd7
+ * data:    X X X X X X - - = 0xfc
+ *
+ * (We just ignore this one --- it's useless and optional.)
+ */
+
+/*
+ * IDAM record:
+ * flux:   XXXX-X-X-XXXXXX- = 0xf57e
+ * clock:  X X - - - X X X  = 0xc7
+ * data:    X X X X X X X - = 0xfe
+ */
+const FluxPattern FM_IDAM_PATTERN(16, 0xf57e);
+
+/*
+ * DAM1 record:
+ * flux:   XXXX-X-X-XX-X-X- = 0xf56a
+ * clock:  X X - - - X X X  = 0xc7
+ * data:    X X X X X - - - = 0xf8
+ */
+const FluxPattern FM_DAM1_PATTERN(16, 0xf56a);
+
+/*
+ * DAM2 record:
+ * flux:   XXXX-X-X-XX-XXXX = 0xf56f
+ * clock:  X X - - - X X X  = 0xc7
+ * data:    X X X X X - X X = 0xfb
+ */
+const FluxPattern FM_DAM2_PATTERN(16, 0xf56f);
+
+/*
+ * TRS80DAM1 record:
+ * flux:   XXXX-X-X-XX-X-XX = 0xf56b
+ * clock:  X X - - - X X X  = 0xc7
+ * data:    X X X X X - - X = 0xf9
+ */
+const FluxPattern FM_TRS80DAM1_PATTERN(16, 0xf56b);
+
+/*
+ * TRS80DAM2 record:
+ * flux:   XXXX-X-X-XX-XXX- = 0xf56e
+ * clock:  X X - - - X X X  = 0xc7
+ * data:    X X X X X - X - = 0xfa
+ */
+const FluxPattern FM_TRS80DAM2_PATTERN(16, 0xf56e);
+
+/* MFM record separator:
+ * 0xA1 is:
+ * data:    1  0  1  0  0  0  0  1  = 0xa1
+ * mfm:     01 00 01 00 10 10 10 01 = 0x44a9
+ * special: 01 00 01 00 10 00 10 01 = 0x4489
+ *                       ^^^^^
+ * When shifted out of phase, the special 0xa1 byte becomes an illegal
+ * encoding (you can't do 10 00). So this can't be spoofed by user data.
+ *
+ * shifted: 10 00 10 01 00 01 00 1
+ *
+ * It's repeated three times.
+ */
+const FluxPattern MFM_PATTERN(48, 0x448944894489LL);
+
+const FluxMatchers ANY_RECORD_PATTERN({
+    &MFM_PATTERN,
+    &FM_IDAM_PATTERN,
+    &FM_DAM1_PATTERN,
+    &FM_DAM2_PATTERN,
+    &FM_TRS80DAM1_PATTERN,
+    &FM_TRS80DAM2_PATTERN,
+});
+
+class IbmDecoder : public Decoder
+{
+public:
+    IbmDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.ibm())
+    {
+    }
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        /* This is really annoying because the IBM record scheme has a
+         * variable-sized header _and_ the checksum covers this header too. So
+         * we have to read and decode a byte at a time until we know where the
+         * record itself starts, saving the bytes for the checksumming later.
+         */
+
+        Bytes bytes;
+        ByteWriter bw(bytes);
+
+        auto readByte = [&]()
+        {
+            auto bits = readRawBits(16);
+            auto bytes = decodeFmMfm(bits).slice(0, 1);
+            uint8_t byte = bytes[0];
+            bw.write_8(byte);
+            return byte;
+        };
+
+        uint8_t id = readByte();
+        if (id == 0xa1)
+        {
+            readByte();
+            readByte();
+            id = readByte();
+        }
+        if (id != IBM_IDAM)
+            return;
+
+        ByteReader br(bytes);
+        br.seek(bw.pos);
+
+        auto bits = readRawBits(IBM_IDAM_LEN * 16);
+        bw += decodeFmMfm(bits).slice(0, IBM_IDAM_LEN);
+
+        IbmDecoderProto::TrackdataProto trackdata;
+        getTrackFormat(
+            trackdata, _sector->physicalTrack, _sector->physicalSide);
+
+        _sector->logicalTrack = br.read_8();
+        _sector->logicalSide = br.read_8();
+        _sector->logicalSector = br.read_8();
+        _currentSectorSize = 1 << (br.read_8() + 7);
+
+        uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, br.pos));
+        uint16_t wantCrc = br.read_be16();
+        if (wantCrc == gotCrc)
+            _sector->status =
+                Sector::DATA_MISSING; /* correct but unintuitive */
+
+        if (trackdata.ignore_side_byte())
+            _sector->logicalSide =
+                Layout::remapSidePhysicalToLogical(_sector->physicalSide);
+        _sector->logicalSide ^= trackdata.invert_side_byte();
+        if (trackdata.ignore_track_byte())
+            _sector->logicalTrack = _sector->physicalTrack;
+
+        for (int sector : trackdata.ignore_sector())
+            if (_sector->logicalSector == sector)
+            {
+                _sector->status = Sector::MISSING;
+                break;
+            }
+    }
+
+    void decodeDataRecord() override
+    {
+        /* This is the same deal as the sector record. */
+
+        Bytes bytes;
+        ByteWriter bw(bytes);
+
+        auto readByte = [&]()
+        {
+            auto bits = readRawBits(16);
+            auto bytes = decodeFmMfm(bits).slice(0, 1);
+            uint8_t byte = bytes[0];
+            bw.write_8(byte);
+            return byte;
+        };
+
+        uint8_t id = readByte();
+        if (id == 0xa1)
+        {
+            readByte();
+            readByte();
+            id = readByte();
+        }
+        if ((id != IBM_DAM1) && (id != IBM_DAM2) && (id != IBM_TRS80DAM1) &&
+            (id != IBM_TRS80DAM2))
+            return;
+
+        ByteReader br(bytes);
+        br.seek(bw.pos);
+
+        auto bits = readRawBits((_currentSectorSize + 2) * 16);
+        bw += decodeFmMfm(bits).slice(0, _currentSectorSize + 2);
+
+        _sector->data = br.read(_currentSectorSize);
+        uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, br.pos));
+        uint16_t wantCrc = br.read_be16();
+        _sector->status =
+            (wantCrc == gotCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
+
+        auto layout = Layout::getLayoutOfTrack(
+            _sector->logicalTrack, _sector->logicalSide);
+        if (_currentSectorSize != layout->sectorSize)
+            std::cerr << fmt::format(
+                "Warning: configured sector size for t{}.h{}.s{} is {} bytes "
+                "but that seen on disk is {} bytes\n",
+                _sector->logicalTrack,
+                _sector->logicalSide,
+                _sector->logicalSector,
+                layout->sectorSize,
+                _currentSectorSize);
+    }
+
+private:
+    void getTrackFormat(IbmDecoderProto::TrackdataProto& trackdata,
+        unsigned track,
+        unsigned head) const
+    {
+        trackdata.Clear();
+        for (const auto& f : _config.trackdata())
+        {
+            if (f.has_track() && (f.track() != track))
+                continue;
+            if (f.has_head() && (f.head() != head))
+                continue;
+
+            trackdata.MergeFrom(f);
+        }
+    }
+
+private:
+    const IbmDecoderProto& _config;
+    unsigned _currentSectorSize;
+    unsigned _currentHeaderLength;
+};
+
+std::unique_ptr<Decoder> createIbmDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new IbmDecoder(config));
+}

arch/ibm/encoder.cc

@@ -0,0 +1,282 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "ibm.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "arch/ibm/ibm.pb.h"
+#include "lib/encoders/encoders.pb.h"
+#include "fmt/format.h"
+#include "lib/proto.h"
+#include "lib/layout.h"
+#include <ctype.h>
+
+/* IAM record separator:
+ * 0xC2 is:
+ * data:    1  1  0  0  0  0  1  0  = 0xc2
+ * mfm:     01 01 00 10 10 10 01 00 = 0x5254
+ * special: 01 01 00 10 00 10 01 00 = 0x5224
+ */
+#define MFM_IAM_SEPARATOR 0x5224
+
+/* FM IAM record:
+ * flux:   XXXX-XXX-XXXX-X- = 0xf77a
+ * clock:  X X - X - X X X  = 0xd7
+ * data:    X X X X X X - - = 0xfc
+ */
+#define FM_IAM_RECORD 0xf77a
+
+/* MFM IAM record:
+ * data:   1  1  1  1  1  1  0  0  = 0xfc
+ * flux:   01 01 01 01 01 01 00 10 = 0x5552
+ */
+#define MFM_IAM_RECORD 0x5552
+
+/* MFM record separator:
+ * 0xA1 is:
+ * data:    1  0  1  0  0  0  0  1  = 0xa1
+ * mfm:     01 00 01 00 10 10 10 01 = 0x44a9
+ * special: 01 00 01 00 10 00 10 01 = 0x4489
+ *                       ^^^^^
+ * When shifted out of phase, the special 0xa1 byte becomes an illegal
+ * encoding (you can't do 10 00). So this can't be spoofed by user data.
+ *
+ * shifted: 10 00 10 01 00 01 00 1
+ *
+ * It's repeated three times.
+ */
+#define MFM_RECORD_SEPARATOR 0x4489
+#define MFM_RECORD_SEPARATOR_BYTE 0xa1
+
+/* MFM IDAM byte:
+ * data:    1  1  1  1  1  1  1  0  = 0xfe
+ * mfm:     01 01 01 01 01 01 01 00 = 0x5554
+ */
+
+/* MFM DAM byte:
+ * data:    1  1  1  1  1  0  1  1  = 0xfb
+ * mfm:     01 01 01 01 01 00 01 01 = 0x5545
+ */
+
+static uint8_t decodeUint16(uint16_t raw)
+{
+    Bytes b;
+    ByteWriter bw(b);
+    bw.write_be16(raw);
+    return decodeFmMfm(b.toBits())[0];
+}
+
+class IbmEncoder : public Encoder
+{
+public:
+    IbmEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.ibm())
+    {
+    }
+
+private:
+    void writeRawBits(uint32_t data, int width)
+    {
+        _cursor += width;
+        _lastBit = data & 1;
+        for (int i = 0; i < width; i++)
+        {
+            unsigned pos = _cursor - i - 1;
+            if (pos < _bits.size())
+                _bits[pos] = data & 1;
+            data >>= 1;
+        }
+    }
+
+    void getEncoderTrackData(IbmEncoderProto::TrackdataProto& trackdata,
+        unsigned track,
+        unsigned head)
+    {
+        trackdata.Clear();
+        for (const auto& f : _config.trackdata())
+        {
+            if (f.has_track() && (f.track() != track))
+                continue;
+            if (f.has_head() && (f.head() != head))
+                continue;
+
+            trackdata.MergeFrom(f);
+        }
+    }
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        IbmEncoderProto::TrackdataProto trackdata;
+        getEncoderTrackData(
+            trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
+
+        auto trackLayout = Layout::getLayoutOfTrack(
+            trackInfo->logicalTrack, trackInfo->logicalSide);
+
+        auto writeBytes = [&](const Bytes& bytes)
+        {
+            if (trackdata.use_fm())
+                encodeFm(_bits, _cursor, bytes);
+            else
+                encodeMfm(_bits, _cursor, bytes, _lastBit);
+        };
+
+        auto writeFillerRawBytes = [&](int count, uint16_t byte)
+        {
+            for (int i = 0; i < count; i++)
+                writeRawBits(byte, 16);
+        };
+
+        auto writeFillerBytes = [&](int count, uint8_t byte)
+        {
+            Bytes b{byte};
+            for (int i = 0; i < count; i++)
+                writeBytes(b);
+        };
+
+        double clockRateUs = trackdata.target_clock_period_us();
+        if (!trackdata.use_fm())
+            clockRateUs /= 2.0;
+        int bitsPerRevolution =
+            (trackdata.target_rotational_period_ms() * 1000.0) / clockRateUs;
+        _bits.resize(bitsPerRevolution);
+        _cursor = 0;
+
+        uint8_t idamUnencoded = decodeUint16(trackdata.idam_byte());
+        uint8_t damUnencoded = decodeUint16(trackdata.dam_byte());
+
+        uint8_t sectorSize = 0;
+        {
+            int s = trackLayout->sectorSize >> 7;
+            while (s > 1)
+            {
+                s >>= 1;
+                sectorSize += 1;
+            }
+        }
+
+        uint16_t gapFill = trackdata.gap_fill_byte();
+
+        writeFillerRawBytes(trackdata.gap0(), gapFill);
+        if (trackdata.emit_iam())
+        {
+            writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+            if (!trackdata.use_fm())
+            {
+                for (int i = 0; i < 3; i++)
+                    writeRawBits(MFM_IAM_SEPARATOR, 16);
+            }
+            writeRawBits(
+                trackdata.use_fm() ? FM_IAM_RECORD : MFM_IAM_RECORD, 16);
+            writeFillerRawBytes(trackdata.gap1(), gapFill);
+        }
+
+        bool first = true;
+        for (const auto& sectorData : sectors)
+        {
+            if (!first)
+                writeFillerRawBytes(trackdata.gap3(), gapFill);
+            first = false;
+
+            /* Writing the sector and data records are fantastically annoying.
+             * The CRC is calculated from the *very start* of the record, and
+             * include the malformed marker bytes. Our encoder doesn't know
+             * about this, of course, with the result that we have to construct
+             * the unencoded header, calculate the checksum, and then use the
+             * same logic to emit the bytes which require special encoding
+             * before encoding the rest of the header normally. */
+
+            {
+                Bytes header;
+                ByteWriter bw(header);
+
+                writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+                if (!trackdata.use_fm())
+                {
+                    for (int i = 0; i < 3; i++)
+                        bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
+                }
+                bw.write_8(idamUnencoded);
+                bw.write_8(sectorData->logicalTrack);
+                bw.write_8(
+                    sectorData->logicalSide ^ trackdata.invert_side_byte());
+                bw.write_8(sectorData->logicalSector);
+                bw.write_8(sectorSize);
+                uint16_t crc = crc16(CCITT_POLY, header);
+                bw.write_be16(crc);
+
+                int conventionalHeaderStart = 0;
+                if (!trackdata.use_fm())
+                {
+                    for (int i = 0; i < 3; i++)
+                        writeRawBits(MFM_RECORD_SEPARATOR, 16);
+                    conventionalHeaderStart += 3;
+                }
+                writeRawBits(trackdata.idam_byte(), 16);
+                conventionalHeaderStart += 1;
+
+                writeBytes(header.slice(conventionalHeaderStart));
+            }
+
+            writeFillerRawBytes(trackdata.gap2(), gapFill);
+
+            {
+                Bytes data;
+                ByteWriter bw(data);
+
+                writeFillerBytes(trackdata.use_fm() ? 6 : 12, 0x00);
+                if (!trackdata.use_fm())
+                {
+                    for (int i = 0; i < 3; i++)
+                        bw.write_8(MFM_RECORD_SEPARATOR_BYTE);
+                }
+                bw.write_8(damUnencoded);
+
+                Bytes truncatedData =
+                    sectorData->data.slice(0, trackLayout->sectorSize);
+                bw += truncatedData;
+                uint16_t crc = crc16(CCITT_POLY, data);
+                bw.write_be16(crc);
+
+                int conventionalHeaderStart = 0;
+                if (!trackdata.use_fm())
+                {
+                    for (int i = 0; i < 3; i++)
+                        writeRawBits(MFM_RECORD_SEPARATOR, 16);
+                    conventionalHeaderStart += 3;
+                }
+                writeRawBits(trackdata.dam_byte(), 16);
+                conventionalHeaderStart += 1;
+
+                writeBytes(data.slice(conventionalHeaderStart));
+            }
+        }
+
+        if (_cursor >= _bits.size())
+            error("track data overrun");
+        while (_cursor < _bits.size())
+            writeFillerRawBytes(1, gapFill);
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        fluxmap->appendBits(_bits,
+            calculatePhysicalClockPeriod(clockRateUs * 1e3,
+                trackdata.target_rotational_period_ms() * 1e6));
+        return fluxmap;
+    }
+
+private:
+    const IbmEncoderProto& _config;
+    std::vector<bool> _bits;
+    unsigned _cursor;
+    bool _lastBit;
+};
+
+std::unique_ptr<Encoder> createIbmEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new IbmEncoder(config));
+}

arch/ibm/ibm.h

@@ -0,0 +1,37 @@
+#ifndef IBM_H
+#define IBM_H
+
+/* IBM format (i.e. ordinary PC floppies). */
+
+#define IBM_MFM_SYNC 0xA1  /* sync byte for MFM */
+#define IBM_IAM 0xFC       /* start-of-track record */
+#define IBM_IAM_LEN 1      /* plus prologue */
+#define IBM_IDAM 0xFE      /* sector header */
+#define IBM_IDAM_LEN 7     /* plus prologue */
+#define IBM_DAM1 0xF8      /* sector data (type 1) */
+#define IBM_DAM2 0xFB      /* sector data (type 2) */
+#define IBM_TRS80DAM1 0xF9 /* sector data (TRS-80 directory) */
+#define IBM_TRS80DAM2 0xFA /* sector data (TRS-80 directory) */
+#define IBM_DAM_LEN 1      /* plus prologue and user data */
+
+/* Length of a DAM record is determined by the previous sector header. */
+
+struct IbmIdam
+{
+    uint8_t id;
+    uint8_t track;
+    uint8_t side;
+    uint8_t sector;
+    uint8_t sectorSize;
+    uint8_t crc[2];
+};
+
+class Encoder;
+class Decoder;
+class DecoderProto;
+class EncoderProto;
+
+extern std::unique_ptr<Decoder> createIbmDecoder(const DecoderProto& config);
+extern std::unique_ptr<Encoder> createIbmEncoder(const EncoderProto& config);
+
+#endif

arch/ibm/ibm.proto

@@ -0,0 +1,43 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message IbmDecoderProto {
+	// Next: 11
+	message TrackdataProto {
+		optional int32 track = 7              [(help) = "if set, the format applies only to this track"];
+		optional int32 head = 8                  [(help) = "if set, the format applies only to this head"];
+
+		optional bool ignore_side_byte = 2       [default = false, (help) = "ignore side byte in sector header"];
+		optional bool ignore_track_byte = 6      [default = false, (help) = "ignore track byte in sector header"];
+		optional bool invert_side_byte = 4       [default = false, (help) = "invert the side byte in the sector header"];
+
+		repeated int32 ignore_sector = 10        [(help) = "sectors with these IDs will not be read"];
+	}
+
+	repeated TrackdataProto trackdata = 1;
+}
+
+message IbmEncoderProto {
+	// Next: 20
+	message TrackdataProto {
+		optional int32 track = 15        [(help) = "if set, the format applies only to this track"];
+		optional int32 head = 16            [(help) = "if set, the format applies only to this head"];
+
+		optional bool emit_iam = 3          [default=true, (help) = "whether to emit an IAM record"];
+		optional double target_clock_period_us = 5  [default=4, (help) = "data clock rate on target disk"];
+		optional bool use_fm = 6            [default=false, (help) = "whether to use FM encoding rather than MFM"];
+		optional int32 idam_byte = 7        [default=0x5554, (help) = "16-bit raw bit pattern of IDAM byte"];
+		optional int32 dam_byte = 8         [default=0x5545, (help) = "16-bit raw bit pattern of DAM byte"];
+		optional int32 gap0 = 9             [default=80, (help) = "size of gap 1 (the post-index gap)"];
+		optional int32 gap1 = 10            [default=50, (help) = "size of gap 2 (the post-ID gap)"];
+		optional int32 gap2 = 11            [default=22, (help) = "size of gap 3 (the pre-data gap)"];
+		optional int32 gap3 = 12            [default=80, (help) = "size of gap 4 (the post-data or format gap)"];
+		optional bool invert_side_byte = 19 [default=false, (help) = "invert the side byte before writing"];
+		optional int32 gap_fill_byte = 18   [default=0x9254, (help) = "16-bit raw bit pattern of gap fill byte"];
+		optional double target_rotational_period_ms = 1 [default=200, (help) = "rotational period of target disk"];
+	}
+
+	repeated TrackdataProto trackdata = 1;
+}
+

arch/macintosh/decoder.cc

@@ -0,0 +1,195 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "macintosh.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include <string.h>
+#include <algorithm>
+
+const FluxPattern SECTOR_RECORD_PATTERN(24, MAC_SECTOR_RECORD);
+const FluxPattern DATA_RECORD_PATTERN(24, MAC_DATA_RECORD);
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+
+static int decode_data_gcr(uint8_t gcr)
+{
+    switch (gcr)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case gcr:                \
+        return data;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+/* This is extremely inspired by the MESS implementation, written by Nathan
+ * Woods and R. Belmont:
+ * https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
+ */
+static Bytes decode_crazy_data(const Bytes& input, Sector::Status& status)
+{
+    Bytes output;
+    ByteWriter bw(output);
+    ByteReader br(input);
+
+    static const int LOOKUP_LEN = MAC_SECTOR_LENGTH / 3;
+
+    uint8_t b1[LOOKUP_LEN + 1];
+    uint8_t b2[LOOKUP_LEN + 1];
+    uint8_t b3[LOOKUP_LEN + 1];
+
+    for (int i = 0; i <= LOOKUP_LEN; i++)
+    {
+        uint8_t w4 = br.read_8();
+        uint8_t w1 = br.read_8();
+        uint8_t w2 = br.read_8();
+        uint8_t w3 = (i != 174) ? br.read_8() : 0;
+
+        b1[i] = (w1 & 0x3F) | ((w4 << 2) & 0xC0);
+        b2[i] = (w2 & 0x3F) | ((w4 << 4) & 0xC0);
+        b3[i] = (w3 & 0x3F) | ((w4 << 6) & 0xC0);
+    }
+
+    /* Copy from the user's buffer to our buffer, while computing
+     * the three-byte data checksum. */
+
+    uint32_t c1 = 0;
+    uint32_t c2 = 0;
+    uint32_t c3 = 0;
+    unsigned count = 0;
+    for (;;)
+    {
+        c1 = (c1 & 0xFF) << 1;
+        if (c1 & 0x0100)
+            c1++;
+
+        uint8_t val = b1[count] ^ c1;
+        c3 += val;
+        if (c1 & 0x0100)
+        {
+            c3++;
+            c1 &= 0xFF;
+        }
+        bw.write_8(val);
+
+        val = b2[count] ^ c3;
+        c2 += val;
+        if (c3 > 0xFF)
+        {
+            c2++;
+            c3 &= 0xFF;
+        }
+        bw.write_8(val);
+
+        if (output.size() == 524)
+            break;
+
+        val = b3[count] ^ c2;
+        c1 += val;
+        if (c2 > 0xFF)
+        {
+            c1++;
+            c2 &= 0xFF;
+        }
+        bw.write_8(val);
+        count++;
+    }
+
+    uint8_t c4 = ((c1 & 0xC0) >> 6) | ((c2 & 0xC0) >> 4) | ((c3 & 0xC0) >> 2);
+    c1 &= 0x3f;
+    c2 &= 0x3f;
+    c3 &= 0x3f;
+    c4 &= 0x3f;
+    uint8_t g4 = br.read_8();
+    uint8_t g3 = br.read_8();
+    uint8_t g2 = br.read_8();
+    uint8_t g1 = br.read_8();
+    if ((g4 == c4) && (g3 == c3) && (g2 == c2) && (g1 == c1))
+        status = Sector::OK;
+
+    return output;
+}
+
+uint8_t decode_side(uint8_t side)
+{
+    /* Mac disks, being weird, use the side byte to encode both the side (in
+     * bit 5) and also whether we're above track 0x3f (in bit 0).
+     */
+
+    return !!(side & 0x20);
+}
+
+class MacintoshDecoder : public Decoder
+{
+public:
+    MacintoshDecoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw24() != MAC_SECTOR_RECORD)
+            return;
+
+        /* Read header. */
+
+        auto header = toBytes(readRawBits(7 * 8)).slice(0, 7);
+
+        uint8_t encodedTrack = decode_data_gcr(header[0]);
+        if (encodedTrack != (_sector->physicalTrack & 0x3f))
+            return;
+
+        uint8_t encodedSector = decode_data_gcr(header[1]);
+        uint8_t encodedSide = decode_data_gcr(header[2]);
+        uint8_t formatByte = decode_data_gcr(header[3]);
+        uint8_t wantedsum = decode_data_gcr(header[4]);
+
+        if (encodedSector > 11)
+            return;
+
+        _sector->logicalTrack = _sector->physicalTrack;
+        _sector->logicalSide = decode_side(encodedSide);
+        _sector->logicalSector = encodedSector;
+        uint8_t gotsum =
+            (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;
+        if (wantedsum == gotsum)
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+    }
+
+    void decodeDataRecord() override
+    {
+        if (readRaw24() != MAC_DATA_RECORD)
+            return;
+
+        /* Read data. */
+
+        readRawBits(8); /* skip spare byte */
+        auto inputbuffer = toBytes(readRawBits(MAC_ENCODED_SECTOR_LENGTH * 8))
+                               .slice(0, MAC_ENCODED_SECTOR_LENGTH);
+
+        for (unsigned i = 0; i < inputbuffer.size(); i++)
+            inputbuffer[i] = decode_data_gcr(inputbuffer[i]);
+
+        _sector->status = Sector::BAD_CHECKSUM;
+        Bytes userData = decode_crazy_data(inputbuffer, _sector->status);
+        _sector->data.clear();
+        _sector->data.writer()
+            .append(userData.slice(12, 512))
+            .append(userData.slice(0, 12));
+    }
+};
+
+std::unique_ptr<Decoder> createMacintoshDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new MacintoshDecoder(config));
+}

arch/macintosh/encoder.cc

@@ -0,0 +1,258 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "macintosh.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "fmt/format.h"
+#include "lib/encoders/encoders.pb.h"
+#include "lib/layout.h"
+#include "arch/macintosh/macintosh.pb.h"
+#include <ctype.h>
+
+static bool lastBit;
+
+static double clockRateUsForTrack(unsigned track)
+{
+    if (track < 16)
+        return 2.63;
+    if (track < 32)
+        return 2.89;
+    if (track < 48)
+        return 3.20;
+    if (track < 64)
+        return 3.57;
+    return 3.98;
+}
+
+static unsigned sectorsForTrack(unsigned track)
+{
+    if (track < 16)
+        return 12;
+    if (track < 32)
+        return 11;
+    if (track < 48)
+        return 10;
+    if (track < 64)
+        return 9;
+    return 8;
+}
+
+static int encode_data_gcr(uint8_t gcr)
+{
+    switch (gcr)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case data:               \
+        return gcr;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+/* This is extremely inspired by the MESS implementation, written by Nathan
+ * Woods and R. Belmont:
+ * https://github.com/mamedev/mame/blob/4263a71e64377db11392c458b580c5ae83556bc7/src/lib/formats/ap_dsk35.cpp
+ */
+static Bytes encode_crazy_data(const Bytes& input)
+{
+    Bytes output;
+    ByteWriter bw(output);
+    ByteReader br(input);
+
+    uint8_t w1, w2, w3, w4;
+
+    static const int LOOKUP_LEN = MAC_SECTOR_LENGTH / 3;
+
+    uint8_t b1[LOOKUP_LEN + 1];
+    uint8_t b2[LOOKUP_LEN + 1];
+    uint8_t b3[LOOKUP_LEN + 1];
+
+    uint32_t c1 = 0;
+    uint32_t c2 = 0;
+    uint32_t c3 = 0;
+    for (int j = 0;; j++)
+    {
+        c1 = (c1 & 0xff) << 1;
+        if (c1 & 0x0100)
+            c1++;
+
+        uint8_t val = br.read_8();
+        c3 += val;
+        if (c1 & 0x0100)
+        {
+            c3++;
+            c1 &= 0xff;
+        }
+        b1[j] = (val ^ c1) & 0xff;
+
+        val = br.read_8();
+        c2 += val;
+        if (c3 > 0xff)
+        {
+            c2++;
+            c3 &= 0xff;
+        }
+        b2[j] = (val ^ c3) & 0xff;
+
+        if (br.pos == 524)
+            break;
+
+        val = br.read_8();
+        c1 += val;
+        if (c2 > 0xff)
+        {
+            c1++;
+            c2 &= 0xff;
+        }
+        b3[j] = (val ^ c2) & 0xff;
+    }
+    uint32_t c4 = ((c1 & 0xc0) >> 6) | ((c2 & 0xc0) >> 4) | ((c3 & 0xc0) >> 2);
+    b3[LOOKUP_LEN] = 0;
+
+    for (int i = 0; i <= LOOKUP_LEN; i++)
+    {
+        w1 = b1[i] & 0x3f;
+        w2 = b2[i] & 0x3f;
+        w3 = b3[i] & 0x3f;
+        w4 = ((b1[i] & 0xc0) >> 2);
+        w4 |= ((b2[i] & 0xc0) >> 4);
+        w4 |= ((b3[i] & 0xc0) >> 6);
+
+        bw.write_8(w4);
+        bw.write_8(w1);
+        bw.write_8(w2);
+
+        if (i != LOOKUP_LEN)
+            bw.write_8(w3);
+    }
+
+    bw.write_8(c4 & 0x3f);
+    bw.write_8(c3 & 0x3f);
+    bw.write_8(c2 & 0x3f);
+    bw.write_8(c1 & 0x3f);
+
+    return output;
+}
+
+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 uint8_t encode_side(uint8_t track, uint8_t side)
+{
+    /* Mac disks, being weird, use the side byte to encode both the side (in
+     * bit 5) and also whether we're above track 0x3f (in bit 0).
+     */
+
+    return (side ? 0x20 : 0x00) | ((track > 0x3f) ? 0x01 : 0x00);
+}
+
+static void write_sector(std::vector<bool>& bits,
+    unsigned& cursor,
+    const std::shared_ptr<const Sector>& sector)
+{
+    if ((sector->data.size() != 512) && (sector->data.size() != 524))
+        error("unsupported sector size --- you must pick 512 or 524");
+
+    write_bits(bits, cursor, 0xff, 1 * 8); /* pad byte */
+    for (int i = 0; i < 7; i++)
+        write_bits(bits, cursor, 0xff3fcff3fcffLL, 6 * 8); /* sync */
+    write_bits(bits, cursor, MAC_SECTOR_RECORD, 3 * 8);
+
+    uint8_t encodedTrack = sector->logicalTrack & 0x3f;
+    uint8_t encodedSector = sector->logicalSector;
+    uint8_t encodedSide =
+        encode_side(sector->logicalTrack, sector->logicalSide);
+    uint8_t formatByte = MAC_FORMAT_BYTE;
+    uint8_t headerChecksum =
+        (encodedTrack ^ encodedSector ^ encodedSide ^ formatByte) & 0x3f;
+
+    write_bits(bits, cursor, encode_data_gcr(encodedTrack), 1 * 8);
+    write_bits(bits, cursor, encode_data_gcr(encodedSector), 1 * 8);
+    write_bits(bits, cursor, encode_data_gcr(encodedSide), 1 * 8);
+    write_bits(bits, cursor, encode_data_gcr(formatByte), 1 * 8);
+    write_bits(bits, cursor, encode_data_gcr(headerChecksum), 1 * 8);
+
+    write_bits(bits, cursor, 0xdeaaff, 3 * 8);
+    write_bits(bits, cursor, 0xff3fcff3fcffLL, 6 * 8); /* sync */
+    write_bits(bits, cursor, MAC_DATA_RECORD, 3 * 8);
+    write_bits(bits, cursor, encode_data_gcr(sector->logicalSector), 1 * 8);
+
+    Bytes wireData;
+    wireData.writer()
+        .append(sector->data.slice(512, 12))
+        .append(sector->data.slice(0, 512));
+    for (uint8_t b : encode_crazy_data(wireData))
+        write_bits(bits, cursor, encode_data_gcr(b), 1 * 8);
+
+    write_bits(bits, cursor, 0xdeaaff, 3 * 8);
+}
+
+class MacintoshEncoder : public Encoder
+{
+public:
+    MacintoshEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.macintosh())
+    {
+    }
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        double clockRateUs = clockRateUsForTrack(trackInfo->logicalTrack);
+        int bitsPerRevolution = 200000.0 / clockRateUs;
+        std::vector<bool> bits(bitsPerRevolution);
+        unsigned cursor = 0;
+
+        fillBitmapTo(bits,
+            cursor,
+            _config.post_index_gap_us() / clockRateUs,
+            {true, false});
+        lastBit = false;
+
+        for (const auto& sector : sectors)
+            write_sector(bits, cursor, sector);
+
+        if (cursor >= bits.size())
+            error("track data overrun by {} bits", cursor - bits.size());
+        fillBitmapTo(bits, cursor, bits.size(), {true, false});
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        fluxmap->appendBits(
+            bits, calculatePhysicalClockPeriod(clockRateUs * 1e3, 200e6));
+        return fluxmap;
+    }
+
+private:
+    const MacintoshEncoderProto& _config;
+};
+
+std::unique_ptr<Encoder> createMacintoshEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new MacintoshEncoder(config));
+}

arch/macintosh/macintosh.h

@@ -0,0 +1,23 @@
+#ifndef MACINTOSH_H
+#define MACINTOSH_H
+
+#define MAC_SECTOR_RECORD 0xd5aa96 /* 1101 0101 1010 1010 1001 0110 */
+#define MAC_DATA_RECORD 0xd5aaad   /* 1101 0101 1010 1010 1010 1101 */
+
+#define MAC_SECTOR_LENGTH 524 /* yes, really */
+#define MAC_ENCODED_SECTOR_LENGTH 703
+#define MAC_FORMAT_BYTE 0x22
+
+#define MAC_TRACKS_PER_DISK 80
+
+class Encoder;
+class Decoder;
+class DecoderProto;
+class EncoderProto;
+
+extern std::unique_ptr<Decoder> createMacintoshDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createMacintoshEncoder(
+    const EncoderProto& config);
+
+#endif

arch/macintosh/macintosh.proto

@@ -0,0 +1,11 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message MacintoshDecoderProto {}
+
+message MacintoshEncoderProto {
+	optional double post_index_gap_us = 1 [default = 0.0,
+		(help) = "post-index gap before first sector header (microseconds)."];
+}
+

arch/micropolis/decoder.cc

@@ -0,0 +1,294 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "micropolis.h"
+#include "lib/bytes.h"
+#include "fmt/format.h"
+#include "lib/decoders/decoders.pb.h"
+
+/* The sector has a preamble of MFM 0x00s and uses 0xFF as a sync pattern.
+ *
+ * 00        00        00        F         F
+ * 0000 0000 0000 0000 0000 0000 0101 0101 0101 0101
+ * A    A    A    A    A    A    5    5    5    5
+ */
+static const FluxPattern SECTOR_SYNC_PATTERN(64, 0xAAAAAAAAAAAA5555LL);
+
+/* Pattern to skip past current SYNC. */
+static const FluxPattern SECTOR_ADVANCE_PATTERN(64, 0xAAAAAAAAAAAAAAAALL);
+
+/* Standard Micropolis checksum.  Adds all bytes, with carry. */
+uint8_t micropolisChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint16_t sum = 0;
+    while (!br.eof())
+    {
+        if (sum > 0xFF)
+        {
+            sum -= 0x100 - 1;
+        }
+        sum += br.read_8();
+    }
+    /* The last carry is ignored */
+    return sum & 0xFF;
+}
+
+/* Vector MZOS does not use the standard Micropolis checksum.
+ * The checksum is initially 0.
+ * For each data byte in the 256-byte payload, rotate left,
+ * carrying bit 7 to bit 0.  XOR with the current checksum.
+ *
+ * Unlike the Micropolis checksum, this does not cover the 12-byte
+ * header (track, sector, 10 OS-specific bytes.)
+ */
+uint8_t mzosChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint8_t checksum = 0;
+    uint8_t databyte;
+
+    while (!br.eof())
+    {
+        databyte = br.read_8();
+        checksum ^= ((databyte << 1) | (databyte >> 7));
+    }
+
+    return checksum;
+}
+
+static uint8_t b(uint32_t field, uint8_t pos)
+{
+    return (field >> pos) & 1;
+}
+
+static uint8_t eccNextBit(uint32_t ecc, uint8_t data_bit)
+{
+    // This is 0x81932080 which is 0x0104C981 with reversed bits
+    return b(ecc, 7) ^ b(ecc, 13) ^ b(ecc, 16) ^ b(ecc, 17) ^ b(ecc, 20) ^
+           b(ecc, 23) ^ b(ecc, 24) ^ b(ecc, 31) ^ data_bit;
+}
+
+uint32_t vectorGraphicEcc(const Bytes& bytes)
+{
+    uint32_t e = 0;
+    Bytes payloadBytes = bytes.slice(0, bytes.size() - 4);
+    ByteReader payload(payloadBytes);
+    while (!payload.eof())
+    {
+        uint8_t byte = payload.read_8();
+        for (int i = 0; i < 8; i++)
+        {
+            e = (e << 1) | eccNextBit(e, byte >> 7);
+            byte <<= 1;
+        }
+    }
+    Bytes trailerBytes = bytes.slice(bytes.size() - 4);
+    ByteReader trailer(trailerBytes);
+    uint32_t res = e;
+    while (!trailer.eof())
+    {
+        uint8_t byte = trailer.read_8();
+        for (int i = 0; i < 8; i++)
+        {
+            res = (res << 1) | eccNextBit(e, byte >> 7);
+            e <<= 1;
+            byte <<= 1;
+        }
+    }
+    return res;
+}
+
+/* Fixes bytes when possible, returning true if changed. */
+static bool vectorGraphicEccFix(Bytes& bytes, uint32_t syndrome)
+{
+    uint32_t ecc = syndrome;
+    int pos = (MICROPOLIS_ENCODED_SECTOR_SIZE - 5) * 8 + 7;
+    bool aligned = false;
+    while ((ecc & 0xff000000) == 0)
+    {
+        pos += 8;
+        ecc <<= 8;
+    }
+    for (; pos >= 0; pos--)
+    {
+        bool bit = ecc & 1;
+        ecc >>= 1;
+        if (bit)
+            ecc ^= 0x808264c0;
+        if ((ecc & 0xff07ffff) == 0)
+            aligned = true;
+        if (aligned && pos % 8 == 0)
+            break;
+    }
+    if (pos < 0)
+        return false;
+    bytes[pos / 8] ^= ecc >> 16;
+    return true;
+}
+
+class MicropolisDecoder : public Decoder
+{
+public:
+    MicropolisDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.micropolis())
+    {
+        _checksumType = _config.checksum_type();
+    }
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        nanoseconds_t now = tell().ns();
+
+        /* For all but the first sector, seek to the next sector pulse.
+         * The first sector does not contain the sector pulse in the fluxmap.
+         */
+        if (now != 0)
+        {
+            seekToIndexMark();
+            now = tell().ns();
+        }
+
+        /* Discard a possible partial sector at the end of the track.
+         * This partial sector could be mistaken for a conflicted sector, if
+         * whatever data read happens to match the checksum of 0, which is
+         * rare, but has been observed on some disks. There's 570uS of slack in
+         * each sector, after accounting for preamble, data, and postamble.
+         */
+        if (now > (getFluxmapDuration() - 12.0e6))
+        {
+            seekToIndexMark();
+            return 0;
+        }
+
+        nanoseconds_t clock = seekToPattern(SECTOR_SYNC_PATTERN);
+
+        auto syncDelta = tell().ns() - now;
+        /* Due to the weak nature of the Micropolis SYNC patern,
+         * it's possible to detect a false SYNC during the gap
+         * between the sector pulse and the write gate.  If the SYNC
+         * is detected less than 100uS after the sector pulse, search
+         * for another valid SYNC.
+         *
+         * Reference: Vector Micropolis Disk Controller Board Technical
+         * Information Manual, pp. 1-16.
+         */
+        if ((syncDelta > 0) && (syncDelta < 100e3))
+        {
+            seekToPattern(SECTOR_ADVANCE_PATTERN);
+            clock = seekToPattern(SECTOR_SYNC_PATTERN);
+        }
+
+        _sector->headerStartTime = tell().ns();
+
+        /* seekToPattern() can skip past the index hole, if this happens
+         * too close to the end of the Fluxmap, discard the sector. The
+         * preamble was expected to be 640uS long.
+         */
+        if (_sector->headerStartTime > (getFluxmapDuration() - 11.3e6))
+        {
+            return 0;
+        }
+
+        return clock;
+    }
+
+    void decodeSectorRecord() override
+    {
+        readRawBits(48);
+        auto rawbits = readRawBits(MICROPOLIS_ENCODED_SECTOR_SIZE * 16);
+        auto bytes =
+            decodeFmMfm(rawbits).slice(0, MICROPOLIS_ENCODED_SECTOR_SIZE);
+
+        bool eccPresent = bytes[274] == 0xaa;
+        uint32_t ecc = 0;
+        if (_config.ecc_type() == MicropolisDecoderProto::VECTOR && eccPresent)
+        {
+            ecc = vectorGraphicEcc(bytes.slice(0, 274));
+            if (ecc != 0)
+            {
+                vectorGraphicEccFix(bytes, ecc);
+                ecc = vectorGraphicEcc(bytes.slice(0, 274));
+            }
+        }
+
+        ByteReader br(bytes);
+
+        int syncByte = br.read_8(); /* sync */
+        if (syncByte != 0xFF)
+            return;
+
+        _sector->logicalTrack = br.read_8();
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = br.read_8();
+        if (_sector->logicalSector > 15)
+            return;
+        if (_sector->logicalTrack > 76)
+            return;
+        if (_sector->logicalTrack != _sector->physicalTrack)
+            return;
+
+        br.read(10); /* OS data or padding */
+        auto data = br.read(MICROPOLIS_PAYLOAD_SIZE);
+        uint8_t wantChecksum = br.read_8();
+
+        /* If not specified, automatically determine the checksum type.
+         * Once the checksum type is determined, it will be used for the
+         * entire disk.
+         */
+        if (_checksumType == MicropolisDecoderProto::AUTO)
+        {
+            /* Calculate both standard Micropolis (MDOS, CP/M, OASIS) and MZOS
+             * checksums */
+            if (wantChecksum == micropolisChecksum(bytes.slice(1, 2 + 266)))
+            {
+                _checksumType = MicropolisDecoderProto::MICROPOLIS;
+            }
+            else if (wantChecksum ==
+                     mzosChecksum(bytes.slice(
+                         MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE)))
+            {
+                _checksumType = MicropolisDecoderProto::MZOS;
+                std::cout << "Note: MZOS checksum detected." << std::endl;
+            }
+        }
+
+        uint8_t gotChecksum;
+
+        if (_checksumType == MicropolisDecoderProto::MZOS)
+        {
+            gotChecksum = mzosChecksum(
+                bytes.slice(MICROPOLIS_HEADER_SIZE, MICROPOLIS_PAYLOAD_SIZE));
+        }
+        else
+        {
+            gotChecksum = micropolisChecksum(bytes.slice(1, 2 + 266));
+        }
+
+        br.read(5); /* 4 byte ECC and ECC-present flag */
+
+        if (_config.sector_output_size() == MICROPOLIS_PAYLOAD_SIZE)
+            _sector->data = data;
+        else if (_config.sector_output_size() == MICROPOLIS_ENCODED_SECTOR_SIZE)
+            _sector->data = bytes;
+        else
+            error("Sector output size may only be 256 or 275");
+        if (wantChecksum == gotChecksum && (!eccPresent || ecc == 0))
+            _sector->status = Sector::OK;
+        else
+            _sector->status = Sector::BAD_CHECKSUM;
+    }
+
+private:
+    const MicropolisDecoderProto& _config;
+    MicropolisDecoderProto_ChecksumType
+        _checksumType; /* -1 = auto, 1 = Micropolis, 2=MZOS */
+};
+
+std::unique_ptr<Decoder> createMicropolisDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new MicropolisDecoder(config));
+}

arch/micropolis/encoder.cc

@@ -0,0 +1,136 @@
+#include "lib/globals.h"
+#include "micropolis.h"
+#include "lib/sector.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/image.h"
+#include "lib/encoders/encoders.pb.h"
+
+static void write_sector(std::vector<bool>& bits,
+    unsigned& cursor,
+    const std::shared_ptr<const Sector>& sector,
+    MicropolisEncoderProto::EccType eccType)
+{
+    if ((sector->data.size() != 256) &&
+        (sector->data.size() != MICROPOLIS_ENCODED_SECTOR_SIZE))
+        error("unsupported sector size --- you must pick 256 or 275");
+
+    int fullSectorSize = 40 + MICROPOLIS_ENCODED_SECTOR_SIZE + 40 + 35;
+    auto fullSector = std::make_shared<std::vector<uint8_t>>();
+    fullSector->reserve(fullSectorSize);
+    /* sector preamble */
+    for (int i = 0; i < 40; i++)
+        fullSector->push_back(0);
+    Bytes sectorData;
+    if (sector->data.size() == MICROPOLIS_ENCODED_SECTOR_SIZE)
+    {
+        if (sector->data[0] != 0xFF)
+            error(
+                "275 byte sector doesn't start with sync byte 0xFF. "
+                "Corrupted sector");
+        uint8_t wantChecksum = sector->data[1 + 2 + 266];
+        uint8_t gotChecksum =
+            micropolisChecksum(sector->data.slice(1, 2 + 266));
+        if (wantChecksum != gotChecksum)
+            std::cerr << "Warning: checksum incorrect. Sector: "
+                      << sector->logicalSector << std::endl;
+        sectorData = sector->data;
+    }
+    else
+    {
+        ByteWriter writer(sectorData);
+        writer.write_8(0xff); /* Sync */
+        writer.write_8(sector->logicalTrack);
+        writer.write_8(sector->logicalSector);
+        for (int i = 0; i < 10; i++)
+            writer.write_8(0); /* Padding */
+        writer += sector->data;
+        writer.write_8(micropolisChecksum(sectorData.slice(1)));
+
+        uint8_t eccPresent = 0;
+        uint32_t ecc = 0;
+        if (eccType == MicropolisEncoderProto::VECTOR)
+        {
+            eccPresent = 0xaa;
+            ecc = vectorGraphicEcc(sectorData + Bytes(4));
+        }
+        writer.write_be32(ecc);
+        writer.write_8(eccPresent);
+    }
+    for (uint8_t b : sectorData)
+        fullSector->push_back(b);
+    /* sector postamble */
+    for (int i = 0; i < 40; i++)
+        fullSector->push_back(0);
+    /* filler */
+    for (int i = 0; i < 35; i++)
+        fullSector->push_back(0);
+
+    if (fullSector->size() != fullSectorSize)
+        error("sector mismatched length");
+    bool lastBit = false;
+    encodeMfm(bits, cursor, fullSector, lastBit);
+    /* filler */
+    for (int i = 0; i < 5; i++)
+    {
+        bits[cursor++] = 1;
+        bits[cursor++] = 0;
+    }
+}
+
+class MicropolisEncoder : public Encoder
+{
+public:
+    MicropolisEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.micropolis())
+    {
+    }
+
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        int bitsPerRevolution =
+            (_config.rotational_period_ms() * 1e3) / _config.clock_period_us();
+
+        std::vector<bool> bits(bitsPerRevolution);
+        std::vector<unsigned> indexes;
+        unsigned prev_cursor = 0;
+        unsigned cursor = 0;
+
+        for (const auto& sectorData : sectors)
+        {
+            indexes.push_back(cursor);
+            prev_cursor = cursor;
+            write_sector(bits, cursor, sectorData, _config.ecc_type());
+        }
+        indexes.push_back(prev_cursor + (cursor - prev_cursor) / 2);
+        indexes.push_back(cursor);
+
+        if (cursor != bits.size())
+            error("track data mismatched length");
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        nanoseconds_t clockPeriod =
+            calculatePhysicalClockPeriod(_config.clock_period_us() * 1e3,
+                _config.rotational_period_ms() * 1e6);
+        auto pos = bits.begin();
+        for (int i = 1; i < indexes.size(); i++)
+        {
+            auto end = bits.begin() + indexes[i];
+            fluxmap->appendBits(std::vector<bool>(pos, end), clockPeriod);
+            fluxmap->appendIndex();
+            pos = end;
+        }
+        return fluxmap;
+    }
+
+private:
+    const MicropolisEncoderProto& _config;
+};
+
+std::unique_ptr<Encoder> createMicropolisEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new MicropolisEncoder(config));
+}

arch/micropolis/micropolis.h

@@ -0,0 +1,22 @@
+#ifndef MICROPOLIS_H
+#define MICROPOLIS_H
+
+#define MICROPOLIS_PAYLOAD_SIZE (256)
+#define MICROPOLIS_HEADER_SIZE (1 + 2 + 10)
+#define MICROPOLIS_ENCODED_SECTOR_SIZE \
+    (MICROPOLIS_HEADER_SIZE + MICROPOLIS_PAYLOAD_SIZE + 6)
+
+class Decoder;
+class Encoder;
+class EncoderProto;
+class DecoderProto;
+
+extern std::unique_ptr<Decoder> createMicropolisDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createMicropolisEncoder(
+    const EncoderProto& config);
+
+extern uint8_t micropolisChecksum(const Bytes& bytes);
+extern uint32_t vectorGraphicEcc(const Bytes& bytes);
+
+#endif

arch/micropolis/micropolis.proto

@@ -0,0 +1,37 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message MicropolisDecoderProto {
+	enum ChecksumType {
+		AUTO = 0;
+		MICROPOLIS = 1;
+		MZOS = 2;
+	}
+	enum EccType {
+		NONE = 0;
+		VECTOR = 1;
+	}
+
+	optional int32 sector_output_size = 1 [default = 256,
+		(help) = "How much of the raw sector should be saved. Must be 256 or 275"];
+	optional ChecksumType checksum_type = 2 [default = AUTO,
+		(help) = "Checksum type to use: AUTO, MICROPOLIS, MZOS"];
+	optional EccType ecc_type = 3 [default = NONE,
+		(help) = "ECC type to use: NONE, VECTOR"];
+}
+
+message MicropolisEncoderProto {
+    enum EccType {
+        NONE = 0;
+        VECTOR = 1;
+    }
+
+    optional double clock_period_us = 1
+        [ default = 2.0, (help) = "clock rate on the real device" ];
+    optional double rotational_period_ms = 2
+        [ default = 200.0, (help) = "rotational period on the real device" ];
+    optional EccType ecc_type = 3 [default = NONE,
+        (help) = "ECC type to use for IMG data: NONE, VECTOR"];
+}
+

arch/mx/decoder.cc

@@ -0,0 +1,83 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "arch/mx/mx.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include <string.h>
+
+const int SECTOR_SIZE = 256;
+
+/*
+ * MX disks are a bunch of sectors glued together with no gaps or sync markers,
+ * following a single beginning-of-track synchronisation and identification
+ * sequence.
+ */
+
+/* FM beginning of track marker:
+ *         0         0         f         3 decoded nibbles
+ *  0 0  0 0  0 0  0 0  1 1  1 1  0 0  1 1
+ * 1010 1010 1010 1010 1111 1111 1010 1111
+ *    a    a    a    a    f    f    a    f encoded nibbles
+ */
+const FluxPattern ID_PATTERN(32, 0xaaaaffaf);
+
+class MxDecoder : public Decoder
+{
+public:
+    MxDecoder(const DecoderProto& config): Decoder(config) {}
+
+    void beginTrack() override
+    {
+        _clock = _sector->clock = seekToPattern(ID_PATTERN);
+        _currentSector = 0;
+    }
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        if (_currentSector == 11)
+        {
+            /* That was the last sector on the disk. */
+            return 0;
+        }
+        else
+            return _clock;
+    }
+
+    void decodeSectorRecord() override
+    {
+        /* Skip the ID pattern and track word, which is only present on the
+         * first sector. We don't trust the track word because some driver
+         * don't write it correctly. */
+
+        if (_currentSector == 0)
+            readRawBits(64);
+
+        auto bits = readRawBits((SECTOR_SIZE + 2) * 16);
+        auto bytes = decodeFmMfm(bits).slice(0, SECTOR_SIZE + 2);
+
+        uint16_t gotChecksum = 0;
+        ByteReader br(bytes);
+        for (int i = 0; i < (SECTOR_SIZE / 2); i++)
+            gotChecksum += br.read_be16();
+        uint16_t wantChecksum = br.read_be16();
+
+        _sector->logicalTrack = _sector->physicalTrack;
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = _currentSector;
+        _sector->data = bytes.slice(0, SECTOR_SIZE).swab();
+        _sector->status =
+            (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+        _currentSector++;
+    }
+
+private:
+    nanoseconds_t _clock;
+    int _currentSector;
+};
+
+std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new MxDecoder(config));
+}

arch/mx/mx.h

@@ -0,0 +1,8 @@
+#ifndef MX_H
+#define MX_H
+
+#include "lib/decoders/decoders.h"
+
+extern std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config);
+
+#endif

arch/mx/mx.proto

@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message MxDecoderProto {}
+

arch/northstar/decoder.cc

@@ -0,0 +1,186 @@
+/* Decoder for North Star 10-sector hard-sectored disks.
+ *
+ * Supports both single- and double-density.  For the sector format and
+ * checksum algorithm, see pp. 33 of the North Star Double Density Controller
+ * manual:
+ *
+ * http://bitsavers.org/pdf/northstar/boards/Northstar_MDS-A-D_1978.pdf
+ *
+ * North Star disks do not contain any track/head/sector information
+ * encoded in the sector record.  For this reason, we have to be absolutely
+ * sure that the hardSectorId is correct.
+ */
+
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "northstar.h"
+#include "lib/bytes.h"
+#include "lib/decoders/decoders.pb.h"
+#include "fmt/format.h"
+
+#define MFM_ID 0xaaaaaaaaaaaa5545LL
+#define FM_ID 0xaaaaaaaaaaaaffefLL
+/*
+ * MFM sectors have 32 bytes of 00's followed by two sync characters,
+ * specified in the North Star MDS manual as 0xFBFB.
+ *
+ * This is true for most disks; however, I found a few disks, including an
+ * original North Star DOS/BASIC v2.2.1 DQ disk) that uses 0xFBnn, where
+ * nn is an incrementing pattern.
+ *
+ * 00        00        00        F         B
+ * 0000 0000 0000 0000 0000 0000 0101 0101 0100 0101
+ * A    A    A    A    A    A    5    5    4    5
+ */
+static const FluxPattern MFM_PATTERN(64, MFM_ID);
+
+/* FM sectors have 16 bytes of 00's followed by 0xFB.
+ * 00        FB
+ * 0000 0000 1111 1111 1110 1111
+ * A    A    F    F    E    F
+ */
+static const FluxPattern FM_PATTERN(64, FM_ID);
+
+const FluxMatchers ANY_SECTOR_PATTERN({
+    &MFM_PATTERN,
+    &FM_PATTERN,
+});
+
+/* Checksum is initially 0.
+ * For each data byte, XOR with the current checksum.
+ * Rotate checksum left, carrying bit 7 to bit 0.
+ */
+uint8_t northstarChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint8_t checksum = 0;
+
+    while (!br.eof())
+    {
+        checksum ^= br.read_8();
+        checksum = ((checksum << 1) | ((checksum >> 7)));
+    }
+
+    return checksum;
+}
+
+class NorthstarDecoder : public Decoder
+{
+public:
+    NorthstarDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.northstar())
+    {
+    }
+
+    /* Search for FM or MFM sector record */
+    nanoseconds_t advanceToNextRecord() override
+    {
+        nanoseconds_t now = tell().ns();
+
+        /* For all but the first sector, seek to the next sector pulse.
+         * The first sector does not contain the sector pulse in the fluxmap.
+         */
+        if (now != 0)
+        {
+            seekToIndexMark();
+            now = tell().ns();
+        }
+
+        /* Discard a possible partial sector at the end of the track.
+         * This partial sector could be mistaken for a conflicted sector, if
+         * whatever data read happens to match the checksum of 0, which is
+         * rare, but has been observed on some disks.
+         */
+        if (now > (getFluxmapDuration() - 21e6))
+        {
+            seekToIndexMark();
+            return 0;
+        }
+
+        int msSinceIndex = std::round(now / 1e6);
+
+        /* Note that the seekToPattern ignores the sector pulses, so if
+         * a sector is not found for some reason, the seek will advance
+         * past one or more sector pulses.  For this reason, calculate
+         * _hardSectorId after the sector header is found.
+         */
+        nanoseconds_t clock = seekToPattern(ANY_SECTOR_PATTERN);
+        _sector->headerStartTime = tell().ns();
+
+        /* Discard a possible partial sector. */
+        if (_sector->headerStartTime > (getFluxmapDuration() - 21e6))
+        {
+            return 0;
+        }
+
+        int sectorFoundTimeRaw = std::round(_sector->headerStartTime / 1e6);
+        int sectorFoundTime;
+
+        /* Round time to the nearest 20ms */
+        if ((sectorFoundTimeRaw % 20) < 10)
+        {
+            sectorFoundTime = (sectorFoundTimeRaw / 20) * 20;
+        }
+        else
+        {
+            sectorFoundTime = ((sectorFoundTimeRaw + 20) / 20) * 20;
+        }
+
+        /* Calculate the sector ID based on time since the index */
+        _hardSectorId = (sectorFoundTime / 20) % 10;
+
+        return clock;
+    }
+
+    void decodeSectorRecord() override
+    {
+        uint64_t id = toBytes(readRawBits(64)).reader().read_be64();
+        unsigned recordSize, payloadSize, headerSize;
+
+        if (id == MFM_ID)
+        {
+            recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_DD;
+            payloadSize = NORTHSTAR_PAYLOAD_SIZE_DD;
+            headerSize = NORTHSTAR_HEADER_SIZE_DD;
+        }
+        else
+        {
+            recordSize = NORTHSTAR_ENCODED_SECTOR_SIZE_SD;
+            payloadSize = NORTHSTAR_PAYLOAD_SIZE_SD;
+            headerSize = NORTHSTAR_HEADER_SIZE_SD;
+        }
+
+        auto rawbits = readRawBits(recordSize * 16);
+        auto bytes = decodeFmMfm(rawbits).slice(0, recordSize);
+        ByteReader br(bytes);
+
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = _hardSectorId;
+        _sector->logicalTrack = _sector->physicalTrack;
+
+        if (headerSize == NORTHSTAR_HEADER_SIZE_DD)
+        {
+            br.read_8(); /* MFM second Sync char, usually 0xFB */
+        }
+
+        _sector->data = br.read(payloadSize);
+        uint8_t wantChecksum = br.read_8();
+        uint8_t gotChecksum =
+            northstarChecksum(bytes.slice(headerSize - 1, payloadSize));
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+
+private:
+    const NorthstarDecoderProto& _config;
+    uint8_t _hardSectorId;
+};
+
+std::unique_ptr<Decoder> createNorthstarDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new NorthstarDecoder(config));
+}

arch/northstar/encoder.cc

@@ -0,0 +1,168 @@
+#include "lib/globals.h"
+#include "northstar.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "lib/image.h"
+#include "lib/encoders/encoders.pb.h"
+
+#define GAP_FILL_SIZE_SD 30
+#define PRE_HEADER_GAP_FILL_SIZE_SD 9
+#define GAP_FILL_SIZE_DD 62
+#define PRE_HEADER_GAP_FILL_SIZE_DD 16
+
+#define GAP1_FILL_BYTE (0x4F)
+#define GAP2_FILL_BYTE (0x4F)
+
+#define TOTAL_SECTOR_BYTES ()
+
+static void write_sector(std::vector<bool>& bits,
+    unsigned& cursor,
+    const std::shared_ptr<const Sector>& sector)
+{
+    int preambleSize = 0;
+    int encodedSectorSize = 0;
+    int gapFillSize = 0;
+    int preHeaderGapFillSize = 0;
+
+    bool doubleDensity;
+
+    switch (sector->data.size())
+    {
+        case NORTHSTAR_PAYLOAD_SIZE_SD:
+            preambleSize = NORTHSTAR_PREAMBLE_SIZE_SD;
+            encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_SD +
+                                NORTHSTAR_ENCODED_SECTOR_SIZE_SD +
+                                GAP_FILL_SIZE_SD;
+            gapFillSize = GAP_FILL_SIZE_SD;
+            preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_SD;
+            doubleDensity = false;
+            break;
+        case NORTHSTAR_PAYLOAD_SIZE_DD:
+            preambleSize = NORTHSTAR_PREAMBLE_SIZE_DD;
+            encodedSectorSize = PRE_HEADER_GAP_FILL_SIZE_DD +
+                                NORTHSTAR_ENCODED_SECTOR_SIZE_DD +
+                                GAP_FILL_SIZE_DD;
+            gapFillSize = GAP_FILL_SIZE_DD;
+            preHeaderGapFillSize = PRE_HEADER_GAP_FILL_SIZE_DD;
+            doubleDensity = true;
+            break;
+        default:
+            error("unsupported sector size --- you must pick 256 or 512");
+            break;
+    }
+
+    int fullSectorSize = preambleSize + encodedSectorSize;
+    auto fullSector = std::make_shared<std::vector<uint8_t>>();
+    fullSector->reserve(fullSectorSize);
+
+    /* sector gap after index pulse */
+    for (int i = 0; i < preHeaderGapFillSize; i++)
+        fullSector->push_back(GAP1_FILL_BYTE);
+
+    /* sector preamble */
+    for (int i = 0; i < preambleSize; i++)
+        fullSector->push_back(0);
+
+    Bytes sectorData;
+    if (sector->data.size() == encodedSectorSize)
+        sectorData = sector->data;
+    else
+    {
+        ByteWriter writer(sectorData);
+        writer.write_8(0xFB); /* sync character */
+        if (doubleDensity == true)
+        {
+            writer.write_8(0xFB); /* Double-density has two sync characters */
+        }
+        writer += sector->data;
+        if (doubleDensity == true)
+        {
+            writer.write_8(northstarChecksum(sectorData.slice(2)));
+        }
+        else
+        {
+            writer.write_8(northstarChecksum(sectorData.slice(1)));
+        }
+    }
+    for (uint8_t b : sectorData)
+        fullSector->push_back(b);
+
+    if (sector->logicalSector != 9)
+    {
+        /* sector postamble */
+        for (int i = 0; i < gapFillSize; i++)
+            fullSector->push_back(GAP2_FILL_BYTE);
+
+        if (fullSector->size() != fullSectorSize)
+            error("sector mismatched length ({}); expected {}, got {}",
+                sector->data.size(),
+                fullSector->size(),
+                fullSectorSize);
+    }
+    else
+    {
+        /* sector postamble */
+        for (int i = 0; i < gapFillSize; i++)
+            fullSector->push_back(GAP2_FILL_BYTE);
+    }
+
+    bool lastBit = false;
+
+    if (doubleDensity == true)
+    {
+        encodeMfm(bits, cursor, fullSector, lastBit);
+    }
+    else
+    {
+        encodeFm(bits, cursor, fullSector);
+    }
+}
+
+class NorthstarEncoder : public Encoder
+{
+public:
+    NorthstarEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.northstar())
+    {
+    }
+
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        int bitsPerRevolution = 100000;
+        double clockRateUs = _config.clock_period_us();
+
+        const auto& sector = *sectors.begin();
+        if (sector->data.size() == NORTHSTAR_PAYLOAD_SIZE_SD)
+            bitsPerRevolution /= 2; // FM
+        else
+            clockRateUs /= 2.00;
+
+        std::vector<bool> bits(bitsPerRevolution);
+        unsigned cursor = 0;
+
+        for (const auto& sectorData : sectors)
+            write_sector(bits, cursor, sectorData);
+
+        if (cursor > bits.size())
+            error("track data overrun");
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        fluxmap->appendBits(bits,
+            calculatePhysicalClockPeriod(
+                clockRateUs * 1e3, _config.rotational_period_ms() * 1e6));
+        return fluxmap;
+    }
+
+private:
+    const NorthstarEncoderProto& _config;
+};
+
+std::unique_ptr<Encoder> createNorthstarEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new NorthstarEncoder(config));
+}

arch/northstar/northstar.h

@@ -0,0 +1,42 @@
+#ifndef NORTHSTAR_H
+#define NORTHSTAR_H
+
+/* Northstar floppies are 10-hard sectored disks with a sector format as
+ * follows:
+ *
+ * |----------------------------------|
+ * | SYNC Byte  | Payload  | Checksum |
+ * |------------+----------+----------|
+ * | 1 (0xFB)   | 256 (SD) |    1     |
+ * | 2 (0xFBFB) | 512 (DD) |          |
+ * |----------------------------------|
+ *
+ */
+
+#define NORTHSTAR_PREAMBLE_SIZE_SD (16)
+#define NORTHSTAR_PREAMBLE_SIZE_DD (32)
+#define NORTHSTAR_HEADER_SIZE_SD (1)
+#define NORTHSTAR_HEADER_SIZE_DD (2)
+#define NORTHSTAR_PAYLOAD_SIZE_SD (256)
+#define NORTHSTAR_PAYLOAD_SIZE_DD (512)
+#define NORTHSTAR_CHECKSUM_SIZE (1)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_SD                    \
+    (NORTHSTAR_HEADER_SIZE_SD + NORTHSTAR_PAYLOAD_SIZE_SD + \
+        NORTHSTAR_CHECKSUM_SIZE)
+#define NORTHSTAR_ENCODED_SECTOR_SIZE_DD                    \
+    (NORTHSTAR_HEADER_SIZE_DD + NORTHSTAR_PAYLOAD_SIZE_DD + \
+        NORTHSTAR_CHECKSUM_SIZE)
+
+class Decoder;
+class Encoder;
+class EncoderProto;
+class DecoderProto;
+
+extern uint8_t northstarChecksum(const Bytes& bytes);
+
+extern std::unique_ptr<Decoder> createNorthstarDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createNorthstarEncoder(
+    const EncoderProto& config);
+
+#endif /* NORTHSTAR */

arch/northstar/northstar.proto

@@ -0,0 +1,13 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message NorthstarDecoderProto {}
+
+message NorthstarEncoderProto {
+    optional double clock_period_us = 1
+        [ default = 4.0, (help) = "clock rate on the real device (for FM)" ];
+    optional double rotational_period_ms = 2
+        [ default = 166.0, (help) = "rotational period on the real device" ];
+}
+

arch/rolandd20/decoder.cc

@@ -0,0 +1,51 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include "lib/bytes.h"
+#include "rolandd20.h"
+#include <string.h>
+
+/* Sector header record:
+ *
+ * BF FF FF FF FF FF FE AB
+ *
+ * This encodes to:
+ *
+ *    e    d    5    5    5    5    5    5
+ * 1110 1101 0101 0101 0101 0101 0101 0101
+ *    5    5    5    5    5    5    5    5
+ * 0101 0101 0101 0101 0101 0101 0101 0101
+ *    5    5    5    5    5    5    5    5
+ * 0101 0101 0101 0101 0101 0101 0101 0101
+ *    5    5    5    4    4    4    4    5
+ * 0101 0101 0101 0100 0100 0100 0100 0101
+ */
+
+static const FluxPattern SECTOR_PATTERN(64, 0xed55555555555555LL);
+
+class RolandD20Decoder : public Decoder
+{
+public:
+    RolandD20Decoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(SECTOR_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        auto rawbits = readRawBits(256);
+        const auto& bytes = decodeFmMfm(rawbits);
+        fmt::print("{} ", _sector->clock);
+        hexdump(std::cout, bytes);
+    }
+};
+
+std::unique_ptr<Decoder> createRolandD20Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new RolandD20Decoder(config));
+}

arch/rolandd20/rolandd20.h

@@ -0,0 +1,4 @@
+#pragma once
+
+extern std::unique_ptr<Decoder> createRolandD20Decoder(
+    const DecoderProto& config);

arch/rolandd20/rolandd20.proto

@@ -0,0 +1,5 @@
+syntax = "proto2";
+
+message RolandD20DecoderProto {}
+
+

arch/smaky6/decoder.cc

@@ -0,0 +1,154 @@
+#include "lib/globals.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "lib/decoders/decoders.h"
+#include "lib/sector.h"
+#include "smaky6.h"
+#include "lib/bytes.h"
+#include "lib/crc.h"
+#include "fmt/format.h"
+#include "lib/decoders/decoders.pb.h"
+#include <string.h>
+#include <algorithm>
+
+static const FluxPattern SECTOR_PATTERN(32, 0x54892aaa);
+
+class Smaky6Decoder : public Decoder
+{
+public:
+    Smaky6Decoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.smaky6())
+    {
+    }
+
+private:
+    /* Returns the sector ID of the _current_ sector. */
+    int advanceToNextSector()
+    {
+        auto previous = tell();
+        seekToIndexMark();
+        auto now = tell();
+        if ((now.ns() - previous.ns()) < 9e6)
+        {
+            seekToIndexMark();
+            auto next = tell();
+            if ((next.ns() - now.ns()) < 9e6)
+            {
+                /* We just found sector 0. */
+
+                _sectorId = 0;
+            }
+            else
+            {
+                /* Spurious... */
+
+                seek(now);
+            }
+        }
+
+        return _sectorId++;
+    }
+
+public:
+    void beginTrack() override
+    {
+        /* Find the start-of-track index marks, which will be an interval
+         * of about 6ms. */
+
+        seekToIndexMark();
+        _sectorId = 99;
+        for (;;)
+        {
+            auto pos = tell();
+            advanceToNextSector();
+            if (_sectorId < 99)
+            {
+                seek(pos);
+                break;
+            }
+
+            if (eof())
+                return;
+        }
+
+        /* Now we know where to start counting, start finding sectors. */
+
+        _sectorStarts.clear();
+        for (;;)
+        {
+            auto now = tell();
+            if (eof())
+                break;
+
+            int id = advanceToNextSector();
+            if (id < 16)
+                _sectorStarts.push_back(std::make_pair(id, now));
+        }
+
+        _sectorIndex = 0;
+    }
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        if (_sectorIndex == _sectorStarts.size())
+        {
+            seekToIndexMark();
+            return 0;
+        }
+
+        const auto& p = _sectorStarts[_sectorIndex++];
+        _sectorId = p.first;
+        seek(p.second);
+
+        nanoseconds_t clock = seekToPattern(SECTOR_PATTERN);
+        _sector->headerStartTime = tell().ns();
+
+        return clock;
+    }
+
+    void decodeSectorRecord() override
+    {
+        readRawBits(33);
+        const auto& rawbits = readRawBits(SMAKY6_RECORD_SIZE * 16);
+        if (rawbits.size() < SMAKY6_SECTOR_SIZE)
+            return;
+        const auto& rawbytes =
+            toBytes(rawbits).slice(0, SMAKY6_RECORD_SIZE * 16);
+
+        /* The Smaky bytes are stored backwards! Backwards! */
+
+        const auto& bytes =
+            decodeFmMfm(rawbits).slice(0, SMAKY6_RECORD_SIZE).reverseBits();
+        ByteReader br(bytes);
+
+        uint8_t track = br.read_8();
+        Bytes data = br.read(SMAKY6_SECTOR_SIZE);
+        uint8_t wantedChecksum = br.read_8();
+        uint8_t gotChecksum = sumBytes(data) & 0xff;
+
+        if (track != _sector->physicalTrack)
+            return;
+
+        _sector->logicalTrack = _sector->physicalTrack;
+        _sector->logicalSide = _sector->physicalSide;
+        _sector->logicalSector = _sectorId;
+
+        _sector->data = data;
+        _sector->status =
+            (wantedChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+
+private:
+    const Smaky6DecoderProto& _config;
+    nanoseconds_t _startOfTrack;
+    std::vector<std::pair<int, Fluxmap::Position>> _sectorStarts;
+    int _sectorId;
+    int _sectorIndex;
+};
+
+std::unique_ptr<Decoder> createSmaky6Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new Smaky6Decoder(config));
+}

arch/smaky6/smaky6.h

@@ -0,0 +1,9 @@
+#ifndef SMAKY6_H
+#define SMAKY6_H
+
+#define SMAKY6_SECTOR_SIZE 256
+#define SMAKY6_RECORD_SIZE (1 + SMAKY6_SECTOR_SIZE + 1)
+
+extern std::unique_ptr<Decoder> createSmaky6Decoder(const DecoderProto& config);
+
+#endif

arch/smaky6/smaky6.proto

@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message Smaky6DecoderProto {}
+

arch/tartu/decoder.cc

@@ -0,0 +1,84 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "arch/tartu/tartu.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include <string.h>
+
+constexpr uint64_t HEADER_BITS = 0xaaaaaaaa44895554LL;
+constexpr uint64_t DATA_BITS =   0xaaaaaaaa44895545LL;
+
+static const FluxPattern HEADER_PATTERN(64, HEADER_BITS);
+static const FluxPattern DATA_PATTERN(64, DATA_BITS);
+
+const FluxMatchers ANY_RECORD_PATTERN {
+    &HEADER_PATTERN,
+    &DATA_PATTERN
+};
+
+class TartuDecoder : public Decoder
+{
+public:
+    TartuDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.tartu())
+    {
+    }
+
+    void beginTrack() override
+    {
+    }
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        if (readRaw64() != HEADER_BITS)
+            return;
+
+        auto bits = readRawBits(16 * 8);
+        auto bytes = decodeFmMfm(bits).slice(0, 8);
+        
+        ByteReader br(bytes);
+        uint8_t track = br.read_8();
+        _sector->logicalTrack = track >> 1;
+        _sector->logicalSide = track & 1;
+        br.skip(1); /* seems always to be 1 */
+        _sector->logicalSector = br.read_8();
+        uint8_t wantChecksum = br.read_8();
+        uint8_t gotChecksum = ~sumBytes(bytes.slice(0, 3));
+        
+        if (wantChecksum == gotChecksum)
+            _sector->status = Sector::DATA_MISSING;
+
+        _sector->status = Sector::DATA_MISSING;
+    }
+
+    void decodeDataRecord() override
+    {
+        if (readRaw64() != DATA_BITS)
+            return;
+    
+        const auto& bits = readRawBits(129 * 16);
+        const auto& bytes = decodeFmMfm(bits).slice(0, 129);
+        _sector->data = bytes.slice(0, 128);
+
+        uint8_t wantChecksum = bytes.reader().seek(128).read_8();
+        uint8_t gotChecksum = ~sumBytes(_sector->data);
+        _sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+
+private:
+    const TartuDecoderProto& _config;
+};
+
+std::unique_ptr<Decoder> createTartuDecoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new TartuDecoder(config));
+}
+

arch/tartu/tartu.h

@@ -0,0 +1,7 @@
+#ifndef TARTU_H
+#define TARTU_H
+
+extern std::unique_ptr<Decoder> createTartuDecoder(const DecoderProto& config);
+
+#endif
+

arch/tartu/tartu.proto

@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message TartuDecoderProto {}
+

arch/tids990/decoder.cc

@@ -0,0 +1,100 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "arch/tids990/tids990.h"
+#include "lib/crc.h"
+#include "lib/fluxmap.h"
+#include "lib/decoders/fluxmapreader.h"
+#include "lib/sector.h"
+#include <string.h>
+#include <fmt/format.h>
+
+/* The Texas Instruments DS990 uses MFM with a scheme similar to a simplified
+ * version of the IBM record scheme (it's actually easier to parse than IBM).
+ * There are 26 sectors per track, each holding a rather weird 288 bytes.
+ */
+
+/*
+ * Sector record:
+ * data:    0  1  0  1  0  1  0  1 .0  0  0  0  1  0  1  0  = 0x550a
+ * mfm:     00 01 00 01 00 01 00 01.00 10 10 10 01 00 01 00 = 0x11112a44
+ * special: 00 01 00 01 00 01 00 01.00 10 00 10 01 00 01 00 = 0x11112244
+ *                                        ^^
+ * When shifted out of phase, the special 0xa1 byte becomes an illegal
+ * encoding (you can't do 10 00). So this can't be spoofed by user data.
+ */
+const uint16_t SECTOR_ID = 0x550a;
+const FluxPattern SECTOR_RECORD_PATTERN(32, 0x11112244);
+
+/*
+ * Data record:
+ * data:    0  1  0  1  0  1  0  1 .0  0  0  0  1  0  1  1  = 0x550b
+ * mfm:     00 01 00 01 00 01 00 01.00 10 10 10 01 00 01 01 = 0x11112a45
+ * special: 00 01 00 01 00 01 00 01.00 10 00 10 01 00 01 01 = 0x11112245
+ *                                        ^^
+ * When shifted out of phase, the special 0xa1 byte becomes an illegal
+ * encoding (you can't do 10 00). So this can't be spoofed by user data.
+ */
+const uint16_t DATA_ID = 0x550b;
+const FluxPattern DATA_RECORD_PATTERN(32, 0x11112245);
+
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
+
+class Tids990Decoder : public Decoder
+{
+public:
+    Tids990Decoder(const DecoderProto& config): Decoder(config) {}
+
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        auto bits = readRawBits(TIDS990_SECTOR_RECORD_SIZE * 16);
+        auto bytes = decodeFmMfm(bits).slice(0, TIDS990_SECTOR_RECORD_SIZE);
+
+        ByteReader br(bytes);
+        if (br.read_be16() != SECTOR_ID)
+            return;
+
+        uint16_t gotChecksum =
+            crc16(CCITT_POLY, bytes.slice(1, TIDS990_SECTOR_RECORD_SIZE - 3));
+
+        _sector->logicalSide = br.read_8() >> 3;
+        _sector->logicalTrack = br.read_8();
+        br.read_8(); /* number of sectors per track */
+        _sector->logicalSector = br.read_8();
+        br.read_be16(); /* sector size */
+        uint16_t wantChecksum = br.read_be16();
+
+        if (wantChecksum == gotChecksum)
+            _sector->status =
+                Sector::DATA_MISSING; /* correct but unintuitive */
+    }
+
+    void decodeDataRecord() override
+    {
+        auto bits = readRawBits(TIDS990_DATA_RECORD_SIZE * 16);
+        auto bytes = decodeFmMfm(bits).slice(0, TIDS990_DATA_RECORD_SIZE);
+
+        ByteReader br(bytes);
+        if (br.read_be16() != DATA_ID)
+            return;
+
+        uint16_t gotChecksum =
+            crc16(CCITT_POLY, bytes.slice(1, TIDS990_DATA_RECORD_SIZE - 3));
+
+        _sector->data = br.read(TIDS990_PAYLOAD_SIZE);
+        uint16_t wantChecksum = br.read_be16();
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createTids990Decoder(const DecoderProto& config)
+{
+    return std::unique_ptr<Decoder>(new Tids990Decoder(config));
+}

arch/tids990/encoder.cc

@@ -0,0 +1,151 @@
+#include "lib/globals.h"
+#include "lib/decoders/decoders.h"
+#include "lib/encoders/encoders.h"
+#include "tids990.h"
+#include "lib/crc.h"
+#include "lib/readerwriter.h"
+#include "lib/image.h"
+#include "arch/tids990/tids990.pb.h"
+#include "lib/encoders/encoders.pb.h"
+#include <fmt/format.h>
+
+static int charToInt(char c)
+{
+    if (isdigit(c))
+        return c - '0';
+    return 10 + tolower(c) - 'a';
+}
+
+static uint8_t decodeUint16(uint16_t raw)
+{
+    Bytes b;
+    ByteWriter bw(b);
+    bw.write_be16(raw);
+    return decodeFmMfm(b.toBits())[0];
+}
+
+class Tids990Encoder : public Encoder
+{
+public:
+    Tids990Encoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.tids990())
+    {
+    }
+
+private:
+    void writeRawBits(uint32_t data, int width)
+    {
+        _cursor += width;
+        _lastBit = data & 1;
+        for (int i = 0; i < width; i++)
+        {
+            unsigned pos = _cursor - i - 1;
+            if (pos < _bits.size())
+                _bits[pos] = data & 1;
+            data >>= 1;
+        }
+    }
+
+    void writeBytes(const Bytes& bytes)
+    {
+        encodeMfm(_bits, _cursor, bytes, _lastBit);
+    }
+
+    void writeBytes(int count, uint8_t byte)
+    {
+        Bytes bytes = {byte};
+        for (int i = 0; i < count; i++)
+            writeBytes(bytes);
+    }
+
+public:
+    std::unique_ptr<Fluxmap> encode(std::shared_ptr<const TrackInfo>& trackInfo,
+        const std::vector<std::shared_ptr<const Sector>>& sectors,
+        const Image& image) override
+    {
+        double clockRateUs = _config.clock_period_us() / 2.0;
+        int bitsPerRevolution =
+            (_config.rotational_period_ms() * 1000.0) / clockRateUs;
+        _bits.resize(bitsPerRevolution);
+        _cursor = 0;
+
+        uint8_t am1Unencoded = decodeUint16(_config.am1_byte());
+        uint8_t am2Unencoded = decodeUint16(_config.am2_byte());
+
+        writeBytes(_config.gap1_bytes(), 0x55);
+
+        bool first = true;
+        for (const auto& sectorData : sectors)
+        {
+            if (!first)
+                writeBytes(_config.gap3_bytes(), 0x55);
+            first = false;
+
+            /* Writing the sector and data records are fantastically annoying.
+             * The CRC is calculated from the *very start* of the record, and
+             * include the malformed marker bytes. Our encoder doesn't know
+             * about this, of course, with the result that we have to construct
+             * the unencoded header, calculate the checksum, and then use the
+             * same logic to emit the bytes which require special encoding
+             * before encoding the rest of the header normally. */
+
+            {
+                Bytes header;
+                ByteWriter bw(header);
+
+                writeBytes(12, 0x55);
+                bw.write_8(am1Unencoded);
+                bw.write_8(sectorData->logicalSide << 3);
+                bw.write_8(sectorData->logicalTrack);
+                bw.write_8(_config.sector_count());
+                bw.write_8(sectorData->logicalSector);
+                bw.write_be16(sectorData->data.size());
+                uint16_t crc = crc16(CCITT_POLY, header);
+                bw.write_be16(crc);
+
+                writeRawBits(_config.am1_byte(), 16);
+                writeBytes(header.slice(1));
+            }
+
+            writeBytes(_config.gap2_bytes(), 0x55);
+
+            {
+                Bytes data;
+                ByteWriter bw(data);
+
+                writeBytes(12, 0x55);
+                bw.write_8(am2Unencoded);
+
+                bw += sectorData->data;
+                uint16_t crc = crc16(CCITT_POLY, data);
+                bw.write_be16(crc);
+
+                writeRawBits(_config.am2_byte(), 16);
+                writeBytes(data.slice(1));
+            }
+        }
+
+        if (_cursor >= _bits.size())
+            error("track data overrun");
+        while (_cursor < _bits.size())
+            writeBytes(1, 0x55);
+
+        auto fluxmap = std::make_unique<Fluxmap>();
+        fluxmap->appendBits(_bits,
+            calculatePhysicalClockPeriod(
+                clockRateUs * 1e3, _config.rotational_period_ms() * 1e6));
+        return fluxmap;
+    }
+
+private:
+    const Tids990EncoderProto& _config;
+    std::vector<bool> _bits;
+    unsigned _cursor;
+    bool _lastBit;
+};
+
+std::unique_ptr<Encoder> createTids990Encoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new Tids990Encoder(config));
+}

arch/tids990/tids990.h

@@ -0,0 +1,18 @@
+#ifndef TIDS990_H
+#define TIDS990_H
+
+#define TIDS990_PAYLOAD_SIZE 288                            /* bytes */
+#define TIDS990_SECTOR_RECORD_SIZE 10                       /* bytes */
+#define TIDS990_DATA_RECORD_SIZE (TIDS990_PAYLOAD_SIZE + 4) /* bytes */
+
+class Encoder;
+class Decoder;
+class DecoderProto;
+class EncoderProto;
+
+extern std::unique_ptr<Decoder> createTids990Decoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createTids990Encoder(
+    const EncoderProto& config);
+
+#endif