Update the HP formats to not use the reserved tracks at the end of the disk.

HP9122 format.

.appveyor.yml

@@ -1,41 +0,0 @@
-version: '{branch}.{build}'
-clone_depth: 1
-skip_tags: true
-
-environment:
-  MSYSTEM: MINGW32
-
-init:
-  - git config --global core.autocrlf input
-
-install:
-  - set PATH=c:\msys64\mingw32\bin;c:\msys64\usr\bin;c:\msys64\bin;%PATH%
-  - echo %PATH%
-  - pacman -S --noconfirm --needed make ninja mingw-w64-i686-libusb mingw-w64-i686-sqlite3 mingw-w64-i686-zlib mingw-w64-i686-gcc zip
-
-build_script:
-  - make
-  - zip -9 fluxengine.zip fluxengine.exe brother120tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
-
-artifacts:
-  - path: fluxengine.zip
-    name: fluxengine.zip
-
-deploy:
-  release: FluxEngine Windows client version $(APPVEYOR_BUILD_NUMBER)
-  description: >
-    This is an automatically built version of the FluxEngine Windows client
-    which is generated whenever a significant checkin has happened. It's had
-    no testing whatsoever.
-
-    To use, download it, put it somewhere, and then run it from a cmd window
-    or other command line shell.
-  provider: GitHub
-  auth_token:
-    secure: dfJjj7fWCoDUz+Ni11OcNPB/U3TNJFwNA2AsL++ChFjniUsZLlC6SDWHiL/t4FZo
-  artifact: fluxengine.zip
-  draft: false
-  prerelease: false
-  on:
-    branch: master
-

.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,99 @@
+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 update && sudo apt install libudev-dev libsqlite3-dev protobuf-compiler libwxgtk3.0-gtk3-dev libfmt-dev
+    - name: make
+      run: CXXFLAGS="-Wp,-D_GLIBCXX_ASSERTIONS" make -j2 -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 -j2 -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
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+    - uses: msys2/setup-msys2@v2
+      with:
+        update: true
+        msystem: MINGW32
+        install: >-
+          diffutils
+          make
+          mingw-w64-i686-fmt
+          mingw-w64-i686-gcc
+          mingw-w64-i686-libusb
+          mingw-w64-i686-pkg-config
+          mingw-w64-i686-protobuf
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-wxWidgets
+          mingw-w64-i686-zlib
+          mingw-w64-i686-nsis
+          zip
+          vim
+    - uses: actions/checkout@v2
+      with:
+        repository: 'davidgiven/fluxengine'
+        path: 'fluxengine'
+    - uses: actions/checkout@v2
+      with:
+        repository: 'davidgiven/fluxengine-testdata'
+        path: 'fluxengine-testdata'
+    - name: build
+      run: make -j2 -C fluxengine
+
+    - name: nsis
+      run: |
+        cd fluxengine
+        strip fluxengine.exe -o fluxengine-stripped.exe
+        strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe
+        makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi
+
+    - name: zip
+      run: |
+        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,123 @@
+name: Autorelease
+
+concurrency: 
+  group: environment-${{ github.head_ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - "master"
+
+jobs:
+  dev-release:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+    - uses: msys2/setup-msys2@v2
+      with:
+        update: true
+        msystem: MINGW32
+        install: >-
+          diffutils
+          make
+          mingw-w64-i686-fmt
+          mingw-w64-i686-gcc
+          mingw-w64-i686-libusb
+          mingw-w64-i686-pkg-config
+          mingw-w64-i686-protobuf
+          mingw-w64-i686-sqlite3
+          mingw-w64-i686-wxWidgets
+          mingw-w64-i686-zlib
+          mingw-w64-i686-nsis
+          zip
+          vim
+    - uses: actions/checkout@v3
+
+    - name: build
+      run: |
+        make -j2
+
+    - name: nsis
+      run: |
+        strip fluxengine.exe -o fluxengine-stripped.exe
+        strip fluxengine-gui.exe -o fluxengine-gui-stripped.exe
+        makensis -v2 -nocd -dOUTFILE=fluxengine-installer.exe extras/windows-installer.nsi
+
+    - name: zip
+      run: |
+        zip -9 fluxengine.zip fluxengine.exe fluxengine-gui.exe upgrade-flux-file.exe brother120tool.exe brother240tool.exe FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex
+
+    - 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
+      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.zip
+          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
+
+    - 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

.travis.yml

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

FluxEngine.cydsn/CortexM3/ARM_GCC_541/Release/FluxEngine.hex

@@ -1,250 +1,250 @@
-:4000000000800020110000005D0D00005D0D0000064A08B5136843F020031360044B1A6803F53F5302331A6000F0B6FEE8460040FA46004010B5054C237833B9044B13B19E
-:400040000448AFF300800123237010BD6081FF1F00000000242E0000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF00000000F7
-:400080006481FF1F242E0000C880FF1F0000000072B6034A13680133136062B6704700BF8081FF1F0A4A0B4B516801310B40002BBEBF03F1FF3363F00F030133536051688E
-:4000C0009368994202BF024B01221A73704700BF8081FF1F0F0000800A4A0B4B916801310B40002BBEBF03F1FF3363F00F030133936091685368994202BF024B01221A7381
-:40010000704700BF8081FF1F0F000080024B012200205A7302F024B98081FF1F10B5C4B2204601F007FA0128FAD110BD70B5C4B220460E4601F006FA314605460246204646
-:4001400001F066FA204601F0F5F90128FAD0284670BD000038B5094CA57B3DB9012002F0A5F84FF47A7000F08FFFE573236823610123A373BDE8384000F0C4BF8081FF1F58
-:4001800038B50446C5B2284602F09CF8012000F091FF44F00200C0B202F094F8012000F089FF284602F08EF8BDE83840062000F06BBF000038B5044D0024285D013400F0EE
-:4001C00029FF102CF9D138BD9481FF1F0FB400B593B014AB53F8042B402102A8019302F013FA02A802F04DF802F057F813B05DF804EB04B07047000010B5044601780648AD
-:40020000FFF7E4FF0420FFF789FF62782146BDE81040042001F0AAB9362E000007B50023ADF804308DF80600032301A88DF80530FFF7E2FF03B05DF804FB0000F8B5234C6B
-:400240000646FFF787FFE37B93B92148FFF7BEFF02F032F818B90120FFF792FFF8E70120FFF78EFF01200023E073636200F022FF3246616A1748FFF7A9FF144D0027636AD6
-:400280009E421BD002F018F828B16B6A13B11248FFF79CFF6762636A9E4205DD0020FFF76FFF6B6A013305E005DA0120FFF768FF6B6A013B6B6200F025FFE0E7322000F0F2
-:4002C000E3FEBDE8F8400548FFF780BF8081FF1F432E00004A2E0000672E0000852E00002DE9F04F97B062B600F076FFBE49042000F09AFFBD4801F0EBFFBD4802F018F8BA
-:40030000BC4802F061F8002002F030F801F0B8FF0221002001F0C4F8B74D0321084600F0D1FE2E462C4600F0EDFEAB7B5BB12A692B689B1A41F28832934204D9002001F0E9
-:40034000B5FF0023AB7301F0E3F818B9AB48FFF73DFF04E001F0E2F80028F7D109E001F0D7F80028FBD0A648FFF730FF032001F03BF9032001F0DEF80128D4D1A14903206B
-:40038000FFF7D4FE94F828109F48FFF71FFF94F82830023B102B00F24B83DFE813F0110049031A00490320004903380049035C004903A4014903100349032F0349033B0369
-:4003C00003238DF818308DF8193008238DF81A301CE394F82A00FFF731FF8C4B13E3FFF7B9FE00236373637B002BFCD0002373733268637B002BFCD0336807218DF8181037
-:400400009B1A04218DF81910ADF81A30FEE20220FFF784FE4FF000090DF1180A4FF480780027C8EB0903DA1907F80A200137402FF9D10220FFF772FE3A465146022001F003
-:4004400095F8B8F10108EBD109F10109B9F1400FE4D16F4BAEE294F82A0001F07BFF606AFFF7ECFE012001F087FF01F0D9FF694BDFF8A8811A78002742F004021A701A7898
-:4004800042F001021A701A7802F0FE021A701A7802F0FE021A7001F0C7FF0220FFF73EFE41F6FF734FF480420121022001F024FF84F8680000F094FD08F807000137102F6D
-:4004C000F8D1DFF85CA100270AF15D081FFA88F90137102F14BF3A4600221AF8010F22440623127D402100F0AFFD4A4646F24C419AF8000000F0BAFD09F14009102F1FFAEC
-:4005000089F9E5D14448FFF761FE00237373637B002BFCD000271422394606A87773DFF8049102F03EF84023099338464FF0FF337760CDF82090B360377301F01DFF012097
-:4005400001F060FF736896F868003344197D00F0FFFC96F8680000F0BDFC012196F8680000F090FC636813B96B7B002BFAD0002794F82BA0A76094F80CB0BBF1000F6CD1F8
-:4005800000F0C0FD6B7B43B1BAF1010A85F80DB003D162E02B7B002B5FD1A26863689A42F8D04FF0000BA36806A808EB83135B440693CBF14003079300F054FA079B0137BF
-:4005C000C3F140039B44099B5FFA8BFB002B34D1022000F0AFFF012826D0637B002B3CD12B7B002BF4D038E0910000000D010000A5000000D90000008081FF1F932E0000D3
-:40060000A62E0000A881FF1FB02E0000282E00002A2E00009C640040BF2E00009481FF1F9381FF1FF085FF1F4022BE49022000F09DFF4023CDF820900993BBF13F0FB2D9DE
-:40064000A268B94B01321340002BBEBF03F1FF3363F00F030133A3608DE7002001F0D2FE042194F8680000F07FFC94F8680000F08BFC0028F9D106A800F028FA0220FFF76E
-:400680004DFDDDF82480B8F1400F06D0C8F1400292B2A449022000F069FF099A32F0400203D11146022000F061FF0220FFF736FDFFF780FD237B33B19C48FFF787FD02209F
-:4006C000FFF7ACFD06E09A4B05A81B88ADF81430FFF792FD627B3946237B9648CDF80080FFF774FDA7E1E76A17F03F0701D003209FE195F82A0001F02DFE012001F042FE8F
-:4007000001F08EFE8C4BDFF834821A7802F0FB021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7001F07DFE686AFFF784FD01214FF4804341F6FF7208468D
-:4007400001F026FE85F8680000F04AFC08F807000137102FF8D1DFF8E891002709F15D031FFA83F803930137102F14BF3A46002219F8010F22440523127D402100F064FC2C
-:40078000414646F24A4299F8000000F06FFC08F14008102F1FFA88F8E5D1F36A00279B09142239464FF0FF3806A877600293C6F80880377301F0F5FE402301200993B946D3
-:4007C00000F012FFBA466268574B01321340002BBCBF03F1FF3363F00F03A168B8BF01338B4200F08F80BAF1000F07D0237B002B40F0A8806B7B002B40F0A480079B002B71
-:4008000034D1B9F1000F0BD07F2246495A540133402BFAD10691079328E0BAF1000F06D1012000F087FE01288346F6D107E0237B002B40F087806B7B002BF1D082E0394921
-:40084000FFF774FC8146374B07905846069300F0CBFEB9F13F0F07F1010706DD029BDB1BD3F1000949EB030900E0D946079BDBB16368039A06A802EB8312099BC3F1400367
-:400880001344089300F031F9099B6BB96A68264B01321340002BBEBF03F1FF3363F00F030133636040230993A36801332AD16B680F2B27D14FF00008C5F8088001F096FD23
-:4008C00085F80C80AB6895F868002B44197D00F03FFB95F8680000F0FDFA012195F8680000F0D0FA85F80D80637B002BFCD04FF00008012086F80D8001F032FD404601F022
-:4009000041FD02E0BAF1000F05D0237BD3B96B7BC3B94FF0010AA36843453FF454AFD5F8088050E7F085FF1F0F000080C42E00002C2E0000DE2E00009A6400409481FF1FF2
-:400940009381FF1F01F058FD012001F01BFD002001F006FD042194F8680000F005FB94F8680000F011FB0028F9D196F8680000F09FFAB9F1000F16D1029BBB420ADD012015
-:4009800000F0D8FD01288046F6D12E49FFF7CEFB3F2803DC012000F061FE04E0404600F023FE0137E8E7FFF705FC237B0BB102203FE0254B1B8805A8ADF8143027E094F880
-:4009C0002A0001F0C7FC606AFFF738FC1F48FFF7FDFB00236373637B002BFCD0012001F0BFFC00237373637B002BFCD0002001F0B7FC1748FFF7EAFB164B04E00020E073A1
-:400A0000FFF71CFC144B1B88ADF8183006A8FFF7F3FB10E094F82A0094F8B034834205D085F8B00401F0A2FC0023EB730B4BEAE70120FFF7F3FB032000F0D6FD0848FFF7DE
-:400A4000C5FB70E4F085FF1F2E2E0000F72E0000052F0000302E0000322E0000342E0000122F000010B54268002A2ED0C368002B2BD00368048A591C01601B78013A13F031
-:400A8000800F817C42601DBF03F0010242EA84030231083114BF43F0020343EA0423817414BF03820382837C072BDCD9028A083B42FA03F38268511C81601370C368013BDD
-:400AC000C360837C083B8374CDE710BD07B5827C42B102AA002102F8011D026001224260FFF7C0FF03B05DF804FB30B543686BB3C2685AB3827C072A0CD8046890F9105057
-:400B0000611C01602178013B41EA05210832018243608274827C018AA2F108042141CBB2090608D5C3F3801363F07F03023A03F08103827402E08474002BD7D08268511C9E
-:400B400081601370C368013BC360CFE730BD0000F8B572B6634B61221A70A3F5F06301221A80192406229C7083F88022522203F5C0731A705C4B5D4A1B785D4EDBB2137059
-:400B800040F618025B4B00251A8041F2512223F8022C33784FF4F07003F0010343EA450501F036FC013C05F0030521D0032DF0D1514B4FF480721A8007221A704F4A0024BB
-:400BC00048211470917002221C705C7103F8032C4B4A4C4D1378062643F001031370414B01221A70484A137843F02003137000E0FEE706FB045300219A881868013401F08C
-:400C0000D0FC082CF5D180224049414801F0BEFC404D4148002450F8041F04F1105303F1400221F0FF064133C9B20B4452005B0002329A4206D012F8027C12F801EC07F8F7
-:400C400006E0F5E7A8420C44E5D1344B00221A60334B34491A68344B344C1A60344A137843F002031370137C43F002031374314B1A7842F040021A700A7842F010020A7053
-:400C80002D4A07CA03C42D49228008682C4A28341060097911712B4A07CA03C422802A4AE83C07CA03C42280284A083407CA03C4274922800A78A4F6785442F008020A70E0
-:400CC000244A01F5AA5112780C31D2B202F00700120908704A70204A442111700FCB07C42380F8BD004800400F010049A1460040254200402242004004400040064000405A
-:400D0000A2430040172F0000E846004054050048000C01407C000048FCFFFF47007600400C060048C243004008760040C051004003500140A0430040D4050048E00500487E
-:400D4000CB510040E8050048F40500480006004822430040CF0100497658004008B501F0E9FB03680C2B00D1FEE7FEE7084908B50B68084A1844821A802A01DC086005E019
-:400D800001F0D8FB0C2303604FF0FF33184608BDCC80FF1F1087FF1F80B51148114B0025C0B1A3F1100192C922460439161BB74204D051F8046F42F8046BF7E7114653F822
-:400DC000046C8C1AA64202D041F8045BF9E701381033E5E701F0B4FBFFF782FAFEE700BF01000000D8300000124A134B10B51A60124A134C1368134843F4007313600023DA
-:400E0000032B98BF54F823204FEA830188BF0E4A0133302B4250F3D10C4B1A780C4B1A700C4B084A1A60FFF793FEBDE8104000F013B800BF0004FA050CED00E014ED00E0BD
-:400E4000000000000080FF1F5D0D0000BC760040C080FF1F08ED00E0074A7F23802113705170064A013BDBB202F80839002BF9D1034A1370704700BFD080FF1FF87B00403D
-:400E80000078004017280FD8084B0001C25C11B142F0200201E002F0DF02C254C25C42F00102C25400207047012070471070004017280BD8064B0001C25C02F0FE02C25490
-:400EC000C25C02F0DF02C25400207047012070471070004017280DD8074900010B4603441A7942F004021A71435C43F00103435400207047012070471070004017280BD81B
-:400F0000064A0001835C490003F0F10301F00E011943815400207047012070471070004041F6FF73994208BF4FF400519A4208BF4FF4005217289FBFC00000F1804000F597
-:400F4000EC4081809ABFC280002001207047000017289FBF034B00011954002088BF0120704700BF1970004017289FBF054B00011A5C01F007019DBF1143195400200120D6
-:400F8000704700BF1470004017289FBF034B0001185C00F0070088BFFF20704714700040172810B51AD8C00001F07F0100F1804441EAC21204F5EC44D2B222709DF80820E8
-:400FC00003F00F0343EA0213DBB263709DF80C30002003F00F03A370E07010BD012010BD10B501F01DFA0A4A5378182B0AD91478013B5370E30003F1804303F5F0431B7841
-:40100000137000E0FF2401F00FFA204610BD00BFD080FF1F030610B5044611D401F000FA084AE300117803F1804303F5F04319705378147001335370BDE8104001F0F4B9E6
-:4010400010BD00BFD080FF1F30B504060CD411F4704509D1C40004F1804404F5F0442180A270E370284630BD012030BD03065FBFC00000F1804000F5F04081805ABFC280E1
-:40108000002001207047000038B50446084DB4F5004F05D9286801F0BBF9A4F50044F6E7034B58686043BDE8384001F0B1B900BFD880FF1F024B1B7A584301F0A9B900BFFA
-:4010C000D880FF1F0E4B00F003001A78490102F0FC02104318701A7801F0600142F080021A701A7802F07F021A701A7802F09F020A431A701A7842F010021A70704700BF04
-:4011000083430040014B01221A70704784430040044B00F00F021B6853F8220043F82210704700BF08ED00E0054A00F01F00126800F1100352F8230042F82310704700BFCE
-:4011400008ED00E000F01F0000F16040490100F56440C9B2017070470F4B10B50F4900240F205C609C60DC601C615C61FFF7D0FF0B4A136843F0040313600A4B4FF47A72B6
-:40118000DB68B3FBF2F3084A1360084B4FF400421C60C3F8E82010BD3486FF1F0512000010E000E0D880FF1F14E000E018E000E0024A136843F002031360704710E000E0D6
-:4011C00008B5FFF7F5FF034A136843F00103136008BD00BF10E000E010B5054CA3691BB9FFF7BAFF0123A361BDE81040FFF7E8BF3486FF1F024B1868C0F30040704700BF15
-:4012000010E000E038B5FFF7F5FF012808D1054D002455F8243003B198470134052CF8D138BD00BF3886FF1F024B03EB80035868596070473486FF1F134B144A1B78DBB2FA
-:401240000360127843EA0223114A0360127843EA0243104A0360127843EA026303600E4B0E4A1B78DBB24360127843EA02230C4A4360127843EA02430A4A4360127843EA46
-:4012800002634360704700BF0301004904010049EC4600400201004901010049000100490501004906010049F8B501F0B9F8444A01271378022643F001031370137C414C95
-:4012C00043F001031374404B02F5E3521F700B3203F8946C1378054603F07F0313700020FFF7E8FE2378394A03F0F90323701378384603F0DF03137023783B432370FFF745
-:40130000D9FE2820FFF7D6FE314B30461A7802F07F021A701A7802F0BF021A70237833432370FFF7C7FE23782A4A43F004032370002313702846537001F076F807211720A4
-:40134000FFF700FF24491720FFF7EEFE07211820FFF7F8FE21491820FFF7E6FE07211520FFF7F0FE1E491520FFF7DEFE07210320FFF7E8FE1B490320FFF7D6FE07210420B7
-:40138000FFF7E0FE18490420FFF7CEFE07210520FFF7D8FE15490520FFF7C6FE07210620FFF7D0FE12490620FFF7BEFE07210C20FFF7C8FEBDE8F8400E490C20FFF7B4BE9F
-:4013C000A5430040944300409D60004012600040F851004084600040031B00003D190000011B0000351A0000611A0000911A0000C91A0000071B000008B51D4B1D4A1870F4
-:40140000002313701C4A13701C4A13701C4A13701C4A13701C4A13701C4A13701C4B4FF400021A604FF080721A604FF400121A6008221A6010221A6020221A6040221A6008
-:40144000144B19B91A7802F0FE0202E01A7842F001021A70104B03221A70802203F8202C012000F0D5FF0D4B04221A7008BD00BF6C86FF1F7286FF1F7086FF1F7186FF1FD1
-:401480006D86FF1F5C86FF1F6F86FF1FE486FF1F00E100E009600040286000401260004070B5074C054623780E461BB9FFF7FCFE0123237031462846BDE87040FFF79CBFE4
-:4014C0005086FF1F0A4A002313700A4A13700A4A13700A4A13700A4A13700A4A13700A4A13700A4B03221A70802203F8202C70477286FF1F7086FF1F7186FF1F6D86FF1F00
-:401500005C86FF1F6F86FF1FE486FF1F28600040014B1878704700BF7186FF1F044B1A7802F0FF001AB118780022C0B21A7070477086FF1F024A0C2303FB002040787047C3
-:401540007886FF1F431E072B0CD8074A064B00010344805C5B7800F00F0043EA0020023880B2704700207047FC5F0040431E072BF0B531D8194B0C2505FB0035EC88184F78
-:40158000A4B2C4F50074A2424FF00C0404FB003488BFEA88E67884BFC2F5007292B2104C46EA12260501EE552C44D6B2667041B90C2202FB0030002343704379DBB2A37019
-:4015C000F0BD0E46074F2F44751AADB2AA42EFD916F8015B3D72F7E7F0BD00BF7886FF1FFC5F004070600040431E072B0AD8064A0C2303FB002300225A705A79034BD2B2AF
-:4016000000011A54704700BF7886FF1FFE5F004038B505461446D1B1431E072B19D8FFF791FFA04203D22846FFF78CFF04460A4609482B011844531A9BB29C4203D9037AE4
-:4016400002F8013BF7E72846FFF7CEFF02E00C4600E00024204638BD70600040431E072B9FBF024B000108221A547047FE5F004030B51A4A1A491B4D0878138803449BB294
-:401680001380194A00231488D8B2A4B27CB1082B0CD050680078C0B2E85450680133013050601088013880B21080ECE718460B780E4C082B0E4A00D040B10E4D2B7883F050
-:4016C00080032B700F232370022301E0022323701370094B1870087030BD00BFE886FF1FE486FF1F006000406086FF1F5D86FF1F7286FF1F6E86FF1FE586FF1F074B0222E6
-:401700001A70074B80221A70064B0F221A70064A00231370054A0120137070477286FF1F6E86FF1F5D86FF1FE486FF1FE586FF1F30B5164B16491B780A8803F00F03023BAF
-:40174000DBB21A4492B20A80124C134A0020118889B279B173B15568215C013BC9B229705168DBB20131516011880130013989B21180ECE7094A1370094A137883F08003B3
-:401780001370084B0B221A7030BD00BF29600040E886FF1F006000406086FF1FE586FF1F6E86FF1F5D86FF1F064A06231370064A01201370054B80221A70054B00221A70F3
-:4017C000704700BF7286FF1F5D86FF1F6E86FF1FE586FF1F054B9A683AB19A68044910709A680988518000229A6070476086FF1FE886FF1F08B5124B1A78D2B21A701B78A1
-:40180000DBB21A0602D50F4A137008BD0220FFF7E1FF0D4B1B7803F06003202B05D0402B06D043B900F0D4FB04E000F057FE01E000F008FD10B9034B03221A7008BD00BFE5
-:40184000286000405D86FF1F0060004008B5084A084B0120197813880B449BB21380064B00221A70FFF7B6FF044B03221A7008BDE886FF1FE486FF1F7286FF1F5D86FF1F8B
-:4018800008B50C4B1B78DBB2042B07D0062B09D0022B0DD1BDE80840FFF7D8BFBDE80840FFF746BF0320FFF795FF034B03221A7008BD00BF7286FF1F5D86FF1F08B5054B25
-:4018C000002201201A70FFF785FF034B03221A7008BD00BF7286FF1F5D86FF1F08B50A4B1A7832B11A78094942F080020A7000221A70074B002201201A70FFF76BFF054BF5
-:4019000003221A7008BD00BF5C86FF1F086000407286FF1F5D86FF1F074B1B78DBB2042B05D0062B05D0022B05D1FFF7A1BEFFF7C5BFFFF7D3BF70477286FF1F38B51D4CBC
-:401940002378DBB2DD0634D518060AD503F00F03012B2ED1FFF74EFF174B1B78190609D538BD5A0602D5FFF7D7FF03E09D0620D5FFF786FF23781B061BD4104B1A78104B10
-:401980001B7813430F4A13701278934211D10A4A0849154613782078DBB2000605D41378DBB20B700B7803F00F0328788342F1D138BD38BD286000405D86FF1F6E86FF1F8B
-:4019C000E586FF1F29600040054A00231380054A916819B191680B7092685380704700BFE886FF1F6086FF1F0E4808B503889BB213B9FFF783FE13E00B4B02221A700B4BBC
-:401A000000221A70FFF7E0FF094AD1799379028843EA012392B2934238BF0380FFF728FE012008BD6086FF1F7286FF1F6E86FF1F00600040084B01221A700F3B9B7C074B8D
-:401A40001A7B02F00302012A1EBFDA7B82F08002DA7301225A7370470B6000407886FF1F094B02221A700F3B93F82230074B1A7E02F00302012A1EBFDA7E82F08002DA7620
-:401A800001225A76704700BF0B6000407886FF1F0B4B04221A700F3B93F83230094B93F8242002F00302012A1EBF93F8272082F0800283F82720012283F82520704700BFB6
-:401AC0000B6000407886FF1F0B4B08221A700F3B93F84230094B93F8302002F00302012A1EBF93F8332082F0800283F83320012283F83120704700BF0B6000407886FF1FD4
-:401B00007047FFF7DFBC00F0B3BB000070B50446184B88B003AA03F11006154618685968083303C5B3422A46F7D11B782B70FCB12223237001AD032328466370FFF77CFB3D
-:401B4000002220461146AB5C08AC04EB131414F8144C03F00F03847008AC234413F8143C0132082AC1700371417100F10400EAD108B070BD472F00002DE9F0411A4D012242
-:401B80002E460C2080274FF0080E184B00FB025C14012344187016499CF805802144B8F1000F07D09CF8044024064CBF887081F802E000E08F7000FB0261CC880132E4B2A3
-:401BC0009C71CC88092AC4F30724DC71CC88E4B21C71C988C1F307215971D6D1054BFF221A70BDE8F08100BF7886FF1F70600040FC5F00400A600040064B074A1B7802EBAA
-:401C0000C30253681A7C824286BF03EBC0035869002070476C86FF1F942F00002DE9F84F424B1A78002A7ED01878414D0138C0B2FFF7E2FFA8463F4AC3681478007ADFF856
-:401C400000C1E4B203EBC0000C2600274FF0010E834268D01A78A24263D11CF80420597891425ED19A7893F8039002F07F0206FB02FA05EB0A01CF7093F802B009F00309EA
-:401C800081F804B093F803B005F80AB0B3F804A0A1F808A093F902A0BAF1000F0BDAB9F1010F0CBF4FF007094FF00D0981F8059081F801E009E0B9F1010F0CBF4FF0050959
-:401CC0004FF0090981F805904F704FEA02191A4906FB0282494481F802E0B2F808A0CAF3072A81F800A0B2F808A05FFA8AFA81F801A0B2F806A011495FFA8AFA494481F873
-:401D000006A0B2F80690C9F3072981F80790B2F806905FFA89F981F80490D288C2F307224A71083394E7BDE8F88F00BF7186FF1F7886FF1F6D86FF1FFC5F00407060004018
-:401D40005E86FF1F08B5064B18780138C0B2FFF753FF20B143681B7900EBC300406908BD7186FF1F00212DE9F84F0B464E4E0C2707FB01F401313219092933554FF000057F
-:401D80009370494CD3701381937253705371EFD118B1464B1D70464B1D70464B1A78002A7FD0187801250138C0B2FFF725FFA8464368DFF8F8E0DB790C2713F0400F3E4BA2
-:401DC0004FF0000C1A7814BF42F0010202F0FE021A70027AD20007FB0541C36803EB02094B4531D093F802A00AF07F06AE4229D10E89B3F804B0B6B25E4538BFA1F808B058
-:401E00001E7893F801B01EF80660B3451AD181F804A0DE780E7093F902A0DE78BAF1000F06F0030607DA012E0CBF07260D264E7181F8018006E0012E0CBF052609264E7156
-:401E400081F801C00833CBE70135092DC3D1C1680A328B1C0A440C200833934209D013F8081C13F80A5C01F07F0100FB01418D72F2E7FFF767FF114B0121186000230C2005
-:401E800000FB0142D3801289013113449BB203F00102134409299BB2F2D1BDE8F84FFFF76BBEBDE8F88F00BF7886FF1F5E86FF1FE686FF1F7186FF1F6F86FF1F7486FF1FB3
-:401EC000114B1B7903F07F035A1E072A19D80F490C2202FB031291781B0141F0010191700021D170517841F002015170127912F0800F074A1A4414BF8D2389239370FFF7DF
-:401F000053BC0020704700BF006000407886FF1FFC5F004030B4194B1A7902F07F02531E072B27D8164B0C2404FB02339978154D01F0FE0199700021D97029461201505DEB
-:401F4000114400F07F0050555A7802F0FD025A701A795B78120605D5012B01D18C7006E00D2303E0012B0CBF082309238B7030BCFFF71ABC002030BC704700BF00600040FD
-:401F80007886FF1FFC5F004010B50D4B0D4C21791878C9B20138C0B2FFF72EFE43681B798B4201D2012909D8074A0848535CDBB24354A3780120DBB2535410BD002010BDFA
-:401FC0007186FF1F006000405E86FF1FE686FF1F38B58A4A8A4C13780021DBB221801806517840F18D800A2900F20581DFE811F05D00030103010301030103010B00030117
-:402000007E0003018200D3787C49012B09D17D4B1A787D4B03EBC2035B685B686360122310E0CB78022B12D18878FFF7E5FD002800F0E180436863606368DA7863689B7836
-:4020400043EA02232380BDE83840FFF7CDBCCB78032B26D16D4B00228878D5B2854209D3664A91786A4AEE2908BF1346634A917881B106E0187801320028F1D0187803446E
-:40208000EAE764499278097C914203D16248FFF73DFD614B1A78002A00F0AD801A78228018E0BDE8384000F019BA13F0030313D0022B40F0A0802380504B0C211B7903F0A6
-:4020C0007F02564B01FB02339A78554BD2B21A7000225A706360B6E702222280514A11784F4AC9B2117053706260ACE7012323804D4BEFE70123238013794C4A1344E9E7A5
-:4021000001390A2977D8DFE801F037764F76067676760A7620009378454ADBB25AE0937803F0FF0153B9404B1A7891425FD01970404B01201870FFF715FE58E0481EC0B251
-:40214000FFF75AFD0028EED155E0FFF71DFF002851D02A4A384913791279DBB2D2B20A70364A3249D25CCB5C9A4240D0314B01221A70FFF753FD3AE003F00303012B2BD01F
-:4021800009D3022B37D11D4B9B78002B33D1BDE83840FFF7BFBE194B9B78012B2BD1214A137803F0FD0315E003F00303012B13D008D3022B1FD1114B9B78E3B9BDE838402F
-:4021C000FFF77EBE0D4B9B78012B14D1154A137843F0020313700AE0084B1A795AB998781B791749DBB2CA5C22EA0002CA54BDE83840FFF7D9BA002038BD00BF00600040AC
-:402200006086FF1F6C86FF1F942F0000F82F0000802F00006B300000EA86FF1F7886FF1F5186FF1F6F86FF1F7186FF1F5E86FF1F5C86FF1F7086FF1F6D86FF1FE686FF1FDE
-:402240007386FF1F074B1A78120609D55B78012B06D1054B054A5A6012781A80FFF7C4BB00207047006000406086FF1F582F0000024B1878C0F38010704700BF8F450040F9
-:40228000704738B505460078012428B100F0D0F8285D0134E4B2F8E738BD08B50D2000F0C7F8BDE808400A2000F0C2B8014B1870704700BF7D640040014B1878704700BF06
-:4022C0006B640040014B1870704700BF78650040074A0223136002F688321268E0215064044A11706FF440710A441360704700BF80E100E001E400E073B515461E460B4C40
-:402300000023019300930A46014618462370FEF747FE324629462078FEF702FE02212078FEF7ECFD207802B070BD00BFF480FF1F064A0123136002F688321268E021106434
-:40234000034A1170A2F540721360704780E100E000E400E0014B1870704700BF7B640040014B1870704700BF79650040014B1870704700BF7A640040014B1870704700BF94
-:402380007C640040014B1870704700BF7E64004073B515461E460B4C01230022019200920A46014618462370FEF7FAFD324629462078FEF7B5FD02212078FEF79FFD20786A
-:4023C00002B070BDF580FF1F064A0423136002F688321268E0219064034A1170A2F202321360704780E100E002E400E0014B04221A60704700E100E0014B04221A60704792
-:4024000080E100E0014B1870704700BF7F6400400230800803D000BF01380046FCD17047EFF3108072B6704780F31088704700BFFEB5494652465B460EB407462449096865
-:402440008A46244A12682448022100F05FF8030020480068C018204900F058F8143883460121C9430C4601250026FFF7D9FF814651460B7823400B7058460130FFF7C8FF80
-:402480003800F04028400B78234003430B705846FFF7BEFF0136072EF2D9002001300138013001200B78234003430B7058460430FFF7AEFF4846FFF7B7FF00BF00BF00BFAE
-:4024C0000EBC894692469B46FEBD00BFAFF30080E880FF1FE480FF1F00C20100094A137803F00303012B0AD0022B09D113790C2103F07F02044B01FB02339B7A00E0137911
-:4025000000207047006000407886FF1F002902D0B0FBF1F0704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BF014B1868704700BF5881FF1F9B
-:402540000E4B70B51E460E4C0025E41AA410A54204D056F8253098470135F8E700F0A2FD084B094C1E46E41AA4100025A54204D056F8253098470135F8E770BDB030000025
-:40258000B0300000B0300000B830000010B5431E0A44914204D011F8014B03F8014FF8E710BD03460244934202D003F8011BFAE7704730B5141E05469BB0184604DA8B2390
-:4025C0002B604FF0FF301DE04FF40273ADF80C300CBF234604F1FF33029305934FF6FF7300910491ADF80E3002461E9B6946284600F072F8431CBCBF8B232B6014B1009B19
-:4026000000221A701BB030BD07B5009313460A46014603480068FFF7CCFF03B05DF804FB5881FF1F2DE9F0478E6882469E420C46914698463ED88A8912F4906F3AD02568CE
-:40264000096902236F1A656905EB450595FBF3F57B1C43449D4238BF1D4653050FD5294600F040FB064698B13A462169FFF78EFFA38923F4906343F08003A38113E02A46F8
-:4026800000F08EFB064670B92169504600F0DEFA0C23CAF80030A3894FF0FF3043F04003A381BDE8F08726613E44266046466561ED1BA560464528BF464649463246206858
-:4026C00000F0A8FAA36800209B1BA36023681E442660BDE8F08700002DE9F04F9DB003938B8980461C060D4616460DD50B695BB9402100F0F7FA2860286118B90C23C8F875
-:402700000030CDE040236B610023099320238DF82930DFF89CB130238DF82A3037463C4614F8013B1BB9B7EB060910D003E0252BF9D02746F3E74B46324629464046FFF774
-:4027400071FF013000F0A780099B4B4409933B78002B00F0A08000234FF0FF3204930793059206938DF853301A930126052221784E4800F041FA671C049B38B14B4A3C4671
-:40278000801A06FA00F018430490EFE7D90644BF20228DF853201A0744BF2B228DF8532022782A2A03D0079A00210A200BE0039A111D12680391002A10DA524243F00200F7
-:4027C000079204900BE027463B780134303B092B03D800FB02320121F5E701B107923B782E2B1ED17B782A2B0AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E09B
-:40280000002319460593781C0A2407463A780130303A092A03D804FB01210123F5E703B1059103223978224800F0E6F940B14023CBEB000003FA00F0049B013718430490DD
-:40284000397806221B487E1C8DF8281000F0D4F988B1194B33B9039B073323F007030833039314E003AB00932A46144B04A94046AFF3008007E003AB00932A460F4B04A9C1
-:40288000404600F093F8B0F1FF3F824603D0099B5344099342E7AB895B0601D4099801E04FF0FF301DB0BDE8F08F00BF7F300000853000008930000000000000252600002B
-:4028C0002DE9F04791461F460A698B6806469342B8BF1346C9F8003091F843200C46DDF8208012B10133C9F800302368990642BFD9F800300233C9F80030256815F006057D
-:4029000010D104F1190A07E00123524639463046C04701301AD00135E368D9F800209B1A9D42F1DB94F843302268003318BF012392060FD5E118302081F843005A1C94F8D8
-:4029400045102244023382F8431003E04FF0FF30BDE8F08704F1430239463046C0470130F4D02268D9F80050E36802F00602042A08BF5D1B2269A3680CBF25EAE5750025B6
-:402980009342C4BF9B1AED184FF000091A344D4509D00123224639463046C0470130D5D009F10109F3E70020BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B6E
-:4029C00001F1430E00F0AE8011D8632A22D009D8002A00F0BB80582A40F0CA8081F84520834955E0642A1ED0692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8802B
-:402A00000A6842F020020A603EE0752A24D0782A3AD0ADE01A6801F14205111D1960136884F84230A8E021681A6811F0800F02D0111D196008E011F0400F02F1040119606C
-:402A400002D0B2F9003000E01368002B3CDA2D225B4284F8432037E021681A6811F0800F02D0111D196007E011F0400F02F10401196001D0138800E01368227E5C496F2ACA
-:402A800014BF0A2208221BE078225A4984F845202268186812F0800F00F104051D6003D1550601D5038800E00368D00744BF42F0200222601BB9226822F0200222601022F1
-:402AC000002084F8430001E049490A226568002DA56008DB206820F0040020602BB9002D7DD175460CE0002B79D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1BC
-:402B0000082A0BD12368DA0708D5236962689A42DEBF302305F8013C05F1FF35C5EB0E0323612EE008681A6810F0800F496903D0101D1860136808E010F0400F02F1040011
-:402B40001860136801D0198000E0196000232361754616E01A68111D1960156800216268284600F049F808B1401B6060636804E004F1420584F8422001232361002384F833
-:402B80004330CDF800803B4603AA21463046FFF797FE013002D14FF0FF3026E023692A4639463046C0470130F5D023689B0710D5002504F1190907E001234A463946304683
-:402BC000C0470130E7D00135E368039A9B1A9D42F2DBE068039B9842B8BF184605E00B7804F1420584F842308AE705B0BDE8F083472F00009030000010B5C9B20244904274
-:402C0000034605D01C7801308C42F8D1184610BD002010BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014D01F8014DF8E710BD994204D011F845
-:402C4000014B02F8014FF8E710BD000038B50546002944D051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A3420DD92268A018834201BF186830
-:402C80005B681218226063600C6023E0A24203D813465A68002AF9D118681918A1420BD12168014458188242196013D110685268014419605A600DE002D90C232B6009E0C1
-:402CC00021686018824201BF106852680918216062605C602846BDE8384000F098B838BD5886FF1F70B5CD1C25F0030508350C2D38BF0C25002D064601DBA94202D90C232E
-:402D0000336046E000F082F8234B1C681A462146A1B10B685B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4615E00C464968E9E7174C2368F3
-:402D40001BB9304600F052F820602946304600F04DF8431C18D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A0ED05A42E25070BD211A30463F
-:402D800000F034F80130EBD10C233360304600F03EF8002070BD00BF5886FF1F5486FF1FF8B5074615460E4621B91146BDE8F840FFF798BF1AB9FFF749FF2846F8BD00F084
-:402DC00027F885420ED929463846FFF78BFF044650B131462A46FFF7D9FB31463846FFF735FF01E03046F8BD2046F8BD38B5064C0023054608462360FDF7B8FF431C02D1FC
-:402E0000236803B12B6038BD0C87FF1F7047704751F8040C0028BEBF091851F8043CC0180438704700000000050209020B020D020F02110213027265706C79203078253091
-:402E4000327800686F6D696E6700626567696E6E696E67207365656B2066726F6D20256420746F20256400756E65787065637465646C7920646574656374656420747261A1
-:402E8000636B20300066696E6973686564207365656B0057616974696E6720666F72205553422E2E2E0055534220726561647900636F6D6D616E64203078253032780077D8
-:402EC00061697400756E64657272756E206166746572202564207061636B65747300636F756E743D256420693D256420643D2564207A7A3D25640073746172742065726153
-:402F000073696E670073746F702065726173696E670069646C650000510040100030510040400000000140000C800C0140800300140140000800400140000A004C014000BF
-:402F400002005001402000303132333435363738394142434445460028000000000104000100000000000000000157494E5553420000303030303100000000000000000004
-:402F800012034D0053004600540031003000300001000000010000009C2F0000010000006B300000000000000000000001000000B42F0000010000003D3000000400000072
-:402FC000D62F0000000000000000000000000000D42F0000FF00000001024000FF00000082024000FF00000003034000FF00000084034000FF000203040309041603460042
-:403000006C007500780045006E00670069006E0065002A0343006F0077006C00610072006B00200054006500630068006E006F006C006F0067006900650073000009022EA4
-:403040000001010080320904000004FF00000007050102400000070582024000000705030340000A0705840340000A12010002FF0001080912006E010002018001430023A3
-:403080002D302B2000686C4C00656667454647003031323334353637383961626364656600000000F8B500BFF8BC08BC9E46704759000000E90D0000F8B500BFF8BC08BC30
-:4030C0009E46704735000000D8300000C880FF1F98000000B0050000000000001087FF1F7F800000030000000000007D00FA0000400000000090D0031550004002000000CD
-:4031000005000000FFFF000000000000000000000000000000000000000000000000000000000000000000007D3000000000000000000000000000000000000000000000DF
-:4031400000000000000000000000000000000000000000000000000000000000000000000000000000000000F880FF1F0000000000000000000000000000000000000000B9
-:40318000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F
-:4031C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000CF
-:40320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008E
-:40324000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004E
-:40328000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E
-:4032C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000CE
-:40330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008D
-:40334000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004D
-:40338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000D
-:4033C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000CD
-:40340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008C
-:40344000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004C
-:40348000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C
-:4034C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000CC
-:40350000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008B
-:40354000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004B
-:40358000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B
-:4035C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000CB
-:40360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008A
-:40364000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004A
-:40368000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000A
-:4036C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000CA
-:403700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000089
-:403740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000049
-:403780000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009
-:4037C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C9
-:403800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000088
-:403840000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000048
-:403880000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008
-:4038C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C8
-:403900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000087
-:403940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047
-:403980000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007
-:4039C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C7
-:403A00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000086
-:403A40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000046
-:403A80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006
-:403AC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C6
-:403B00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000085
-:403B40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000045
-:403B80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005
-:403BC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C5
-:403C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000084
-:403C40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044
-:403C80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004
-:403CC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C4
-:403D00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083
-:403D40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043
-:403D80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003
+:400000000080002011000000A1100000A1100000064A08B5136843F020031360044B1A6803F53F5302331A6001F058F8E8460040FA46004010B5054C237833B9044B13B173
+:400040000448AFF300800123237010BD6081FF1F00000000F0380000084B10B51BB108490848AFF300800848036803B910BD074B002BFBD0BDE81040184700BF0000000021
+:400080006481FF1FF0380000C880FF1F000000000A4A0B4B116801310B40002BBEBF03F1FF3363F03F030133136011685368994202BF024B01221A72704700BF8081FF1FA4
+:4000C0003F0000800A4A0B4B516801310B40002BBEBF03F1FF3363F03F030133536051681368994202BF024B01221A72704700BF8081FF1F3F000080114BDA68196919B905
+:4001000001221A75597514E09969521A19698A4294BF587D00201875187D094908B1002204E0086982428CBF002201224A75DA689A611B7D13B1002002F082B9704700BF34
+:400140008081FF1F10B5C4B2204601F089F90128FAD110BD08B572B60F4B0F49DA680132DA60DA690132C82A08BF0022DA611A6AD8690132A72A08BF00220A621B6A002BEB
+:400180000CBF02230023002814BF184643F0010002F0DAFB62B608BD8081FF1F38B50446C5B2284602F0C4F8062002F099FD44F00200C0B202F0BCF8062002F091FD284602
+:4001C00002F0B6F8BDE83840062002F073BD10B5642402F0A7F828B9FFF7E0FF013CF8D1204610BD012010BD70B5C4B2054620460E4601F035F9012805D0204601F04EFAE3
+:400200002846FFF79FFF204601F032F9314605460246204601F0EEF9204601F021F90028FAD1284670BD000038B5044D0024285D013402F005FD402CF9D138BDA481FF1F75
+:4002400008B502F0FDF9002002F006FA02F018FA02F022FA80B208BD10B50446012002F07FF8642002F026FDFFF7EAFF2080002002F076F8642002F01DFDFFF7E1FF608047
+:4002800010BD08B502F008FB002002F011FB02F023FB02F02DFB80B208BD10B50446FFF796FF322002F006FDFFF7EBFF20800120FFF774FF322002F0FDFCFFF7E2FF6080A1
+:4002C00010BD0FB400B593B014AB53F8042B402102A8019302F0F4FE02A802F0BEF802F0C8F813B05DF804EB04B0704710B5044601780648FFF7E5FF0420FFF723FF62787E
+:400300002146BDE81040042001F002B90C3A000007B50023ADF804308DF80600032301A88DF80530FFF7E2FF03B05DF804FB000010B5074C94F8643043B1002001F0ECFF79
+:40034000002002F083F8002384F8643010BD00BF8081FF1F38B5124D837895F8672004469A4204D0FFF7E4FF002385F86A302368C5F8653022790B4B1A71A378002B14BF38
+:400380000220012002F062F8E078B0FA80F0400902F0D4FA2079BDE8384002F0DBBA00BF8081FF1FE581FF1F38B50D4C94F8645065B904F16500FFF7CDFF012001F0ACFF17
+:4003C0004FF47A7002F076FC84F86A50E368E366012384F86430BDE8384002F0A9BC00BF8081FF1FF8B5214C0546FFF7DDFF94F86A3003B15DB91E48FFF763FFFFF7E7FE5C
+:400400000120002384F86A00236702F069FC2A46216F1848FFF755FF144E0027236F9D4216D001F07FFF00B13767236F9D4205DD0120FFF7B3FE336F013305E005DA002094
+:40044000FFF7ACFE336F013B336702F071FCE5E7322002F02FFC2A2DCCBF0020012002F07FFABDE8F8400448FFF72BBF8081FF1F193A0000203A00003D3A00002DE9F04F9B
+:4004800099B062B602F0BEFC9F49042002F0E2FC9E4801F053FF9E4801F084FF9D4801F0B1FF02F06DF902F03FF8002001F0CEFF01F0D2FF0221002000F088FF012001F05D
+:4004C00001F9954D0321084602F012FC2E462C4602F02EFC95F8643043B1EA6EEB689B1A41F28832934201D9FFF722FF00F0A6FF18B98A48FFF7E5FE04E000F0A5FF0028D3
+:40050000F7D134E000F09AFF10B902F011FCF9E78348FFF7D6FE032001F0C0F88148FFF7D0FE002386F86730FFF73EFFFFF74FFE86F87400FFF7FCFE012386F86730FFF701
+:4005400033FFFFF744FE86F87500FFF7F1FE96F874007549754B96F87520002A14BF0A461A46002808BF19467148FFF7AAFE032000F076FF0128ABD16E48FFF7EBFE6E49CB
+:400580000320FFF731FE94F876106C48FFF799FE94F87630023B142B00F2D783DFE813F01500D5031E00D5032400D5035000D5037600D503DA00D503C201D5030903D50356
+:4005C0002D03D5033403D5034E0303238DF820308DF8213011238DF822302BE394F87800FFF700FF564B22E340F2DC57FFF7DCFE00232375E068227D02F0FF012AB9EB680B
+:400600001B1ABB42F7DD0B4611E083B10022174696F87810F068277594F814E0BEF1000F02D1EB681B1AF7E701329142F3DA07228DF8202004228DF82120ADF82230F9E2BF
+:400640000220FFF77FFD4FF000080DF1200A02F06FFB4FF480790027C9EB0803DA1907F80A200137402FF9D10220FFF76BFD3A465146022000F04CFFB9F10109EBD108F10F
+:400680000108B8F1400FE2D12E4B38E04FF0010A4FF000080DF1200B02F04AFB4FF0000959460120FFF7A0FD08EB090300270493049B1BF807203B44DBB29A4209D08DE89D
+:4006C0000C0041463B464A461F48FFF7FAFD4FF0000A0137402FEBD109F10109B9F5807FDED108F10108B8F1400FD5D151461748FFF7E7FDBAF1000F00F01C81144B1B883D
+:4007000007A8ADF81C3096E255010000F900000091000000C50000008081FF1F523A0000653A00006F3A00004B3A00004F3A0000823A0000E581FF1FF681FF1F9A3A000052
+:40074000F4380000F6380000A93A0000C53A0000F8380000206FFFF745FE94F8780001F0FFFD94F8780001F0E3FD02F015FCB94BDFF8FC821A78002702F0FB021A701A785F
+:4007800042F001021A701A7802F0FE021A701A7802F0FE021A7002F003FC0220FFF7D2FC012141F6FF734FF48042084601F0DEFD84F8B60002F02AFA08F807000137402FA7
+:4007C000F8D1DFF8B0A200270AF195091FFA89F80137402F14BF3A4600221AF8010F2244062392F82420402102F044FA424646F24E419AF8000002F04FFA08F14008402FB5
+:400800001FFA88F8E4D196F8793053B196F87C30336100233375237D002BFCD000233375336100234FF0FF32236062602372236894F8B600234493F8241002F09FF994F82A
+:40084000B60002F05DF9012194F8B60002F030F92368002BFCD0002398467360D6F80CA0012702F065FAE368B4F87A20CAEB030393420DD367B1042195F8B60002F08AF9BC
+:4008800094F8B60002F096F90028F9D107463072237AFBB96A682B689A4202D1002FE0D118E00220FFF74EFC6968402209EB8111022000F02DFE6A68674B01321340002BCA
+:4008C000BEBF03F1FF3363F03F03013308F101086360C6E70220277AFFF734FC00221146022000F015FE0220FFF72CFCFFB2FFF79BFC002001F01CFD37B15848FFF7E1FC90
+:400900000220FFF705FD06E0554B08A81B88ADF82030FFF7EBFC227D4146237A5148FFF7D0FC15E25048FFF7CCFCD4F87A7017F03F0701D0032009E2286FFFF753FD95F83B
+:40094000780001F00DFD95F8780001F0F1FC012001F098FD02F020FB444BDFF814811A7842F004021A701A7842F001021A701A7802F0FE021A701A7802F0FE021A7002F0BF
+:400980000FFB01214FF4804341F6FF72084601F01DFD85F8B60002F039F908F807000137402FF8D1DFF8CC90002709F195031FFA83F804930137402F14BF3A46002219F8F2
+:4009C000010F2244052392F82420402102F052F9414646F2484299F8000002F05DF908F14008402F1FFA88F8E4D100274FF0FF33376098467360BB463B46D6F87A903772EA
+:400A00005FEA99190CBF4FF0010A4FF0000A2168114A01310A40002ABCBF02F1FF3262F03F026068B8BF013282426FD02BB1227A002A7AD12A7D002A77D12068049A059368
+:400A400002EB8010BAF1000F16D040223F2102F003FB1CE09E6400403F000080CF3A0000FA380000E93A0000FC3A000098640040A481FF1FA381FF1F014601370120FFF7BF
+:400A8000B3FBC7EB0903D3F1000A4AEB030A2168B34A01310A40002ABEBF02F1FF3262F03F02013222606268059B01322ED12A683F2A2BD14FF00008C5F8048001F0B4FCE9
+:400AC00085F808806B6895F8B6002B4493F8241002F054F895F8B60002F012F8012195F8B60001F0E5FF95F87E302B6185F81480237D002BFCD04FF00008012086F814800D
+:400B000001F09EFC404601F0BDFC00E023B1237A5BB92B7D4BB90123626842453FF477AF0BF1010BD5F8048071E701F083FC012001F0A8FC002001F083FC042194F8B6004D
+:400B400002F028F894F8B60002F034F880460028F8D196F8B60001F0C1FF337D327A0293012303920193CDF800A05B463A4649467C48FFF7A6FBC6F81080BAF1000F0BD0C6
+:400B8000FFF752FB002001F0D3FB237A63B17648FFF797FB0220D9E0B945F1D073490120FFF722FB0137F7E77148FFF78AFB714B3DE094F8780001F0D3FB206FFFF712FC19
+:400BC0006D48FFF77EFB94F87930236100232375237D002BFCD0012001F032FC00233375237D002BFCD0002001F02AFC002363483361FFF766FB624B19E0002084F86A0088
+:400C0000FFF7F0FB5F4B12E094F8743023B195F875200AB985F8782094F875201AB113B9012385F878305848FFF794FB574B1B88ADF8203008A8FFF759FB89E0FFF778FB0D
+:400C400001F01CFE002001F0BFFD2A2701F0EAFC002001F08DFC3A46002108A802F0FCF917238DF820308DF8217002F061F8002001F052FB002001F0E9FBC82002F01AF8F3
+:400C80000DF12200FFF7E8FA0DF13600FFF705FB02F04EF8012001F0D9FB322002F00AF80DF12600FFF7D8FA0DF13A00FFF7F5FA012001F031FB4FF4967001F0FBFF02F041
+:400CC00037F80DF12E00FFF7C7FA0DF14200FFF7E4FA002001F020FB4FF4967001F0EAFF02F026F8022001F0B1FB322001F0E2FF0DEB0700FFF7B0FA0DF13E00FFF7CDFAF4
+:400D0000012001F009FB4FF4967001F0D3FF02F00FF80DF13200FFF79FFA0DF14600FFF7BCFA002001F0F8FA4FF4967001F0C2FF01F0FEFF002001F089FB002384F86A302F
+:400D400001F01EFD01F0F0FB74E70120FFF7E0FA032000F0A3FC0E48FFF7B3FAFFF7B8BB3F000080063B0000363B00003892FF1F403B0000FC380000483B0000563B00000F
+:400D8000FE38000000390000F681FF1F02390000633B00000F4B1A78120616D55878C0B2012814D11B79DBB2042B02D0052B05D07047094A094B5A60282203E0084A074B07
+:400DC0005A60E0221A8000F043BE002070470120704700BF0060004004390000BC92FF1F2C3900002DE9F04172B6884B61221A70A3F5F06301221A801924854A9C7092E807
+:400E000003008033062283F8002283E80300522203F580731A707F4B7F4A1B787F4EDBB2137040F618027E4B00251A8041F2512223F8022C33784FF4F07003F0010343EAA4
+:400E4000450502F0A1F8013C05F003052ED0032DF0D1744B4FF480721A8007221A70724A002548211570917002221D705D7103F8032C0422DA716D4A6D4C13786D4E43F060
+:400E80000103137012F8013C062743F0030302F8013C2378012243F0800323705B4B1A70654A137843F02003137000E0FEE707FB056300219A881868013502F0CDF8072D6A
+:400EC000F5D15E485E4E002550F8041F05F1105303F14A0221F0FF074B33C9B20B4452005B0002329A4206D012F802EC12F801CC0EF807C0F5E7B0420D44E5D1514A002390
+:400F000013609360136193614F4B504F1A68504BDFF888811A604F4B1A684F4B1A604F4A137843F002031370137C43F0020313742378A2F5863243F040032370413A1378DD
+:400F400043F010031370464A464B07CA03C31A80454A2833106843F8250C127903F8212C424A07CA03C31A80414AE83B07CA03C31A80404A083307CA03C31A803E4A3F4B11
+:400F8000A2F5616203CBC2F8100EC2F8141E1378042043F008031370394B02F5AA521B783D78DBB298F80060EDB203F007010C321B091170F6B2537045F003033B7046F095
+:400FC000030388F800302F4B48221A702E4A402313702E49937013729372082382F81F3220220A7048710A72294A0A20137001F077FE284B88F8006044223D70264D1A709B
+:4010000094E80F0007C52B80BDE8F08100480040680A00480F010049A146004025420040224200400440004006400040A2430040A0430040683B0000E8460040FCFFFF47E7
+:401040009000004800760040700A0048F846004020760040740A00482876004003500140280A0048C0510040340A00483C0A0048480A0048540A004832510040600A004800
+:40108000CF0100491D51004001590040235B0040585B004076580040B0430040F946004008B501F0ADFF03680C2B00D1FEE7FEE7084908B50B68084A1844821A802A01DC75
+:4010C000086005E001F09CFF0C2303604FF0FF33184608BDCC80FF1F8893FF1F80B51148114B0025C0B1A3F1100192C922460439161BB74204D051F8046F42F8046BF7E7E8
+:40110000114653F8046C8C1AA64202D041F8045BF9E701381033E5E701F078FFFFF7AEF9FEE700BF01000000FC3C0000124A134B10B51A60124A134C1368134843F4007367
+:4011400013600023032B98BF54F823204FEA830188BF0E4A0133302B4250F3D10C4B1A780C4B1A700C4B084A1A60FFF73BFEBDE8104001F087BC00BF0004FA050CED00E0A4
+:4011800014ED00E0000000000080FF1FA1100000BC760040C080FF1F08ED00E0F8B501F0FBFE4B4A01271378022643F001031370137C484C43F001031374474B02F5E352FA
+:4011C0001F700B3203F8946C1378054603F07F031370002001F084FD2378404A03F0F90323701378384603F0DF03137023783B43237001F075FD282001F072FD384B304610
+:401200001A7802F07F021A701A7802F0BF021A7023783343237001F063FD2378314A43F0040323700023137053702F4AFF2199540133092BFBD1284601F0B2FE07211720E7
+:4012400001F096FD2949172001F084FD0721182001F08EFD2649182001F07CFD0721152001F086FD2349152001F074FD0721052001F07EFD2049052001F06CFD072106201F
+:4012800001F076FD1D49062001F064FD0721084601F06EFD1A49072001F05CFD0721082001F066FD1749082001F054FD0021162001F05EFD1449162001F04CFD07210C2014
+:4012C00001F056FDBDE8F84010490C2001F042BDA5430040944300409D60004012600040F851004084600040AD92FF1F6B1B0000A5190000691B00009D1A0000C91A0000BE
+:40130000F91A0000311B0000711B0000E51B0000214B224A10B5187000231370204A40201370204A0F2413701F4A13701F4A13701F4A13701F4A13701F4B4FF400021A60B1
+:401340004FF080721A604FF400121A6020221A601860802018604FF480701860174804704FF480001860164B1A70933B19B91A7802F0FE0202E01A7842F001021A70114B50
+:4013800003221A70802203F8202C012001F0FCFD0D4B04221A7010BDC892FF1FCE92FF1FCC92FF1FCD92FF1FC992FF1FB892FF1FCB92FF1F4093FF1F00E100E09E6000407A
+:4013C0009C600040286000401260004070B5074C054623780E461BB9FFF7E0FE0123237031462846BDE87040FFF792BF7892FF1F0A4A002313700A4A13700A4A13700A4A81
+:4014000013700A4A13700A4A13700A4A13700A4B03221A70802203F8202C7047CE92FF1FCC92FF1FCD92FF1FC992FF1FB892FF1FCB92FF1F4093FF1F28600040014B187898
+:40144000704700BFCD92FF1F044B1A7802F0FF001AB118780022C0B21A707047CC92FF1F024A0C2303FB002040787047D492FF1F431E072B0CD8074A064B00010344805C32
+:401480005B7800F00F0043EA0020023880B2704700207047FC5F00401A4A38B50C2303FB00231B79090C13F0800F00F1FF35044619BF8AB24FF480438BB24FF48042032DA1
+:4014C00018D8DFE805F002070C110021084601F0A1FA0DE00021084601F080FA08E00021084601F05FFA03E00021084601F03EFA054B1855EDB2072D03D801F087FB034B10
+:40150000185538BDD492FF1FA492FF1FAD92FF1F431E072B2DE9F0470446894615465CD82F4F0C2202FB0072D388DFF8B8A09BB2C3F500739D424FF00C0303FB007388BF8A
+:40154000D588DB7884BFC5F50075ADB2254A43EA15230601B354B244EBB28AF80130224B1A5C9846FF2A01D1FFF796FF0C2303FB047200215170B9F1000F28D03DB31B4FEB
+:40158000385D01F0ABFA11232946FE2218F8040001F070FB06F5C04278321FFA89F118F8040001F079FB124D18F80410385D01F0E5FA0121385D01F07BFA735D43F002030D
+:4015C0007355735D03F0FD037355BDE8F08703FB04746379DBB28AF80230BDE8F08700BFD492FF1FFC5F0040AD92FF1FA492FF1F706000402DE9F047044615468846002945
+:4016000040D0431E072B3FD8FFF732FFA84203D22046FFF72DFF05461D4E335DFF2B03D141462046FFF738FFDFF868A027011AF8040001F053FA1223FE222946305D01F087
+:4016400019FB07F5C0411FFA88F27831305D01F023FBDFF84490315D1AF8040001F08EFA01211AF8040001F023FA17F8093043F0020307F8093017F8093003F0FD0307F881
+:40168000093002E00D4600E000252846BDE8F087AD92FF1FA492FF1F70600040431E072B0AD8064A0C2303FB002300225A705A79034BD2B200011A54704700BFD492FF1F5D
+:4016C000FE5F0040431E072B9FBF024B000108221A547047FE5F004030B51A4A1A491B4D0878138803449BB21380194A00231488D8B2A4B27CB1082B0CD050680078C0B2EC
+:40170000E85450680133013050601088013880B21080ECE718460B780E4C082B0E4A00D040B10E4D2B7883F080032B700F232370022301E0022323701370094B18700870CA
+:4017400030BD00BF4493FF1F4093FF1F00600040BC92FF1FB992FF1FCE92FF1FCA92FF1F4193FF1F074B02221A70074B80221A70064B0F221A70064A00231370054A012088
+:4017800013707047CE92FF1FCA92FF1FB992FF1F4093FF1F4193FF1F30B5164B16491B780A8803F00F03023BDBB21A4492B20A80124C134A0020118889B279B173B155682C
+:4017C000215C013BC9B229705168DBB20131516011880130013989B21180ECE7094A1370094A137883F080031370084B0B221A7030BD00BF296000404493FF1F006000400F
+:40180000BC92FF1F4193FF1FCA92FF1FB992FF1F064A06231370064A01201370054B80221A70054B00221A70704700BFCE92FF1FB992FF1FCA92FF1F4193FF1F054B9A68E4
+:401840003AB19A68044910709A680988518000229A607047BC92FF1F4493FF1F08B5124B1A78D2B21A701B78DBB21A0602D50F4A137008BD0220FFF7E1FF0D4B1B7803F0CE
+:401880006003202B05D0402B06D043B900F012FC04E001F089FB01E0FFF77CFA10B9034B03221A7008BD00BF28600040B992FF1F0060004008B5084A084B012019781388FA
+:4018C0000B449BB21380064B00221A70FFF7B6FF044B03221A7008BD4493FF1F4093FF1FCE92FF1FB992FF1F08B50C4B1B78DBB2042B07D0062B09D0022B0DD1BDE8084045
+:40190000FFF7D8BFBDE80840FFF746BF0320FFF795FF034B03221A7008BD00BFCE92FF1FB992FF1F08B5054B002201201A70FFF785FF034B03221A7008BD00BFCE92FF1FCA
+:40194000B992FF1F08B50A4B1A7832B11A78094942F080020A7000221A70074B002201201A70FFF76BFF054B03221A7008BD00BFB892FF1F08600040CE92FF1FB992FF1FC0
+:40198000074B1B78DBB2042B05D0062B05D0022B05D1FFF7A1BEFFF7C5BFFFF7D3BF7047CE92FF1F38B51D4C2378DBB2DD0634D518060AD503F00F03012B2ED1FFF74EFF42
+:4019C000174B1B78190609D538BD5A0602D5FFF7D7FF03E09D0620D5FFF786FF23781B061BD4104B1A78104B1B7813430F4A13701278934211D10A4A0849154613782078EB
+:401A0000DBB2000605D41378DBB20B700B7803F00F0328788342F1D138BD38BD28600040B992FF1FCA92FF1F4193FF1F29600040054A00231380054A916819B191680B701D
+:401A400092685380704700BF4493FF1FBC92FF1F0E4808B503889BB213B9FFF783FE13E00B4B02221A700B4B00221A70FFF7E0FF094AD1799379028843EA012392B2934229
+:401A800038BF0380FFF728FE012008BDBC92FF1FCE92FF1FCA92FF1F00600040084B01221A700F3B9B7C074B1A7B02F00302012A1EBFDA7B82F08002DA7301225A73704722
+:401AC0000B600040D492FF1F094B02221A700F3B93F82230074B1A7E02F00302012A1EBFDA7E82F08002DA7601225A76704700BF0B600040D492FF1F0B4B04221A700F3B21
+:401B000093F83230094B93F8242002F00302012A1EBF93F8272082F0800283F82720012283F82520704700BF0B600040D492FF1F0B4B08221A700F3B93F84230094B93F856
+:401B4000302002F00302012A1EBF93F8332082F0800283F83320012283F83120704700BF0B600040D492FF1F7047FFF741BC0000F0B5184B184E19780C27C9B201234FF028
+:401B8000000C31B3CA0720D5144A4FEA031E7244947850782040C5070DD507FB03652C79240608D5147804F0FE0414706D790C4CEDB204F80E50840706D507FB036425795F
+:401BC0002D0658BF84F801C090700133DBB24908D7E7F0BD9F600040D492FF1F70600040FE5F004000F032BF70B50446184B88B003AA03F11006154618685968083303C530
+:401C0000B3422A46F7D11B782B70FCB12223237001AD03232846637001F024F9002220461146AB5C08AC04EB131414F8144C03F00F03847008AC234413F8143C0132082AB1
+:401C4000C1700371417100F10400EAD108B070BD923B00002DE9F0431C4D01222E460C201F274FF0800E4FF0080C194B00FB02581401234418705F70164998F8059021445B
+:401C8000B9F1000F07D098F8044024064CBF887081F802C001E081F802E000FB0261CC880132E4B29C71CC88092AC4F30724DC71CC88E4B21C71C988C1F307215971D4D1CB
+:401CC000054BFF221A70BDE8F08300BFD492FF1F70600040FC5F00400A600040064B074A1B7802EBC30253681A7C824286BF03EBC003586900207047C892FF1FB83B000044
+:401D00002DE9F84F424B1A78002A7ED01878414D0138C0B2FFF7E2FFA8463F4AC3681478007ADFF800C1E4B203EBC0000C2600274FF0010E834268D01A78A24263D11CF829
+:401D40000420597891425ED19A7893F8039002F07F0206FB02FA05EB0A01CF7093F802B009F0030981F804B093F803B005F80AB0B3F804A0A1F808A093F902A0BAF1000FB6
+:401D80000BDAB9F1010F0CBF4FF007094FF00D0981F8059081F801E009E0B9F1010F0CBF4FF005094FF0090981F805904F704FEA02191A4906FB0282494481F802E0B2F806
+:401DC00008A0CAF3072A81F800A0B2F808A05FFA8AFA81F801A0B2F806A011495FFA8AFA494481F806A0B2F80690C9F3072981F80790B2F806905FFA89F981F80490D288FA
+:401E0000C2F307224A71083394E7BDE8F88F00BFCD92FF1FD492FF1FC992FF1FFC5F004070600040BA92FF1F08B5064B18780138C0B2FFF753FF20B143681B7900EBC3008A
+:401E4000406908BDCD92FF1F00212DE9F84F0B464E4E0C2707FB01F401313219092933554FF000059370494CD3701381937253705371EFD118B1464B1D70464B1D70464B16
+:401E80001A78002A7FD0187801250138C0B2FFF725FFA8464368DFF8F8E0DB790C2713F0400F3E4B4FF0000C1A7814BF42F0010202F0FE021A70027AD20007FB0541C368D0
+:401EC00003EB02094B4531D093F802A00AF07F06AE4229D10E89B3F804B0B6B25E4538BFA1F808B01E7893F801B01EF80660B3451AD181F804A0DE780E7093F902A0DE78D3
+:401F0000BAF1000F06F0030607DA012E0CBF07260D264E7181F8018006E0012E0CBF052609264E7181F801C00833CBE70135092DC3D1C1680A328B1C0A440C20083393423E
+:401F400009D013F8081C13F80A5C01F07F0100FB01418D72F2E7FFF767FF114B0121186000230C2000FB0142D3801289013113449BB203F00102134409299BB2F2D1BDE88B
+:401F8000F84FFFF767BEBDE8F88F00BFD492FF1FBA92FF1F4293FF1FCD92FF1FCB92FF1FD092FF1F114B1B7903F07F035A1E072A19D80F490C2202FB031291781B0141F08E
+:401FC000010191700021D170517841F002015170127912F0800F074A1A4414BF8D2389239370FFF715BC0020704700BF00600040D492FF1FFC5F004030B4194B1A7902F0D8
+:402000007F02531E072B27D8164B0C2404FB02339978154D01F0FE0199700021D97029461201505D114400F07F0050555A7802F0FD025A701A795B78120605D5012B01D167
+:402040008C7006E00D2303E0012B0CBF082309238B7030BCFFF7DCBB002030BC704700BF00600040D492FF1FFC5F004010B50D4B0D4C21791878C9B20138C0B2FFF72EFE80
+:4020800043681B798B4201D2012909D8074A0848535CDBB24354A3780120DBB2535410BD002010BDCD92FF1F00600040BA92FF1F4293FF1F38B5874A874C13780021DBB254
+:4020C00021801806517840F188800A2900F20081DFE811F05800FE00FE00FE00FE00FE000B00FE007900FE007D00D3787949012B09D17A4B1A787A4B03EBC2035B685B68FE
+:402100006360122310E0CB78022B12D18878FFF7E5FD002800F0DC80436863606368DA7863689B7843EA02232380BDE83840FFF78FBCCB78032B21D16A4B00228878D5B29B
+:40214000854203D3634A92783AB910E0187801320028F7D018780344F0E75E4A62499278097C914203D16148FFF73EFD5F4B1A78002A00F0AD801A78228018E0BDE8384099
+:4021800000F012BF13F0030313D0022B40F0A0802380504B0C211B7903F07F02544B01FB02339A78534BD2B21A7000225A706360BBE702222280504A11784E4AC9B2117026
+:4021C00053706260B1E7012323804C4BEFE70123238013794A4A1344E9E701390A2977D8DFE801F037764F76067676760A7620009378444ADBB25AE0937803F0FF0153B928
+:402200003E4B1A7891425FD019703F4B01201870FFF71AFE58E0481EC0B2FFF75FFD0028EED155E0FFF722FF002851D0294A374913791279DBB2D2B20A70354A3049D25C1E
+:40224000CB5C9A4240D0304B01221A70FFF758FD3AE003F00303012B2BD009D3022B37D11C4B9B78002B33D1BDE83840FFF7C4BE184B9B78012B2BD11F4A137803F0FD03CA
+:4022800015E003F00303012B13D008D3022B1FD1104B9B78E3B9BDE83840FFF783BE0D4B9B78012B14D1144A137843F0020313700AE0084B1A795AB998781B791549DBB239
+:4022C000CA5C22EA0002CA54BDE83840FFF7A0BA002038BD00600040BC92FF1FC892FF1FB83B00001C3C00008F3C00006093FF1FD492FF1F7992FF1FCB92FF1FCD92FF1FBA
+:40230000BA92FF1FB892FF1FCC92FF1FC992FF1F4293FF1FCF92FF1F014B1870704700BF72640040014B1878704700BF68650040014B1870704700BF7A650040064A0123C8
+:40234000136002F688321268E0211064034A1170A2F540721360704780E100E000E400E0014B1870704700BF7A64004073B515461E460B4C04230022019200920A46014658
+:402380001846237000F022FC32462946207800F0DDFB0221207800F0C7FB207802B070BDD080FF1F074A0223136002F688321268E0215064044A11706FF440710A44136017
+:4023C000704700BF80E100E001E400E073B515461E460B4C05230022019200920A4601461846237000F0F2FB32462946207800F0ADFB0221207800F097FB207802B070BD84
+:40240000D180FF1F064A0423136002F688321268E0219064034A1170A2F202321360704780E100E002E400E0014B04221A60704700E100E0014B04221A60704780E100E013
+:40244000014B1870704700BF7B650040014B1870704700BF73640040704738B505460078012428B100F038FD285D0134E4B2F8E738BD08B50D2000F02FFDBDE808400A20C6
+:4024800000F02ABD014B1870704700BF7865004010B500F081FD204A044613780A2043F002031370137C43F00203137412F80A3C43F0010302F80A3C937943F0010393712B
+:4024C00002F5AB52137843F003031370134B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CCE2203F8062CA3F597530222183B1A70094A137843F0AA
+:402500000803137000F0ECFB064B10222046BDE810401A6000F044BDAB4300400E5900402F5B004080E200E008B500F035FD0F4A137803F0FE031370A2F5AA521D3A13785D
+:4025400003F0FD031370137C03F0FD03137412F80A3C03F0FE0302F80A3C937903F0FE039371BDE8084000F01BBD00BF08590040044A137803F03F0343EA8010C0B2107082
+:40258000704700BF08590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF0000298BF33F910100A4B88BF11461A8042F210734B4341F2E4
+:4025C000883103F6C41393FBF1F305490B60054B1A8070470A590040A43B00004A93FF1F4C93FF1F5093FF1F08B5102000F036FA0721042000F0BCFB0749042000F0AAFB02
+:40260000064A0C20137843F006031370FFF7BCFF034B00221A8008BDE1260000095900404893FF1F10B5054C23781BB9FFF7DCFF01232370BDE81040FFF72ABF7B92FF1FA6
+:40264000044B1A7802F0FB021A701A7842F001021A7070470859004010B5084B1C7814F0010403D10028F9D0002404E0204600F037FB024B1B78204610BD00BF09590040D9
+:40268000034A044B1B881088181A00B2704700BF5093FF1FA25B00400E4A13881BB223B111880A2309B2594301E00B4B19680B4B1B88C01A42F2107300B203FB00F20223F1
+:4026C00091FBF3F30028D8BF5B42134493FBF1F000B270474A93FF1F4C93FF1F4893FF1F7047000010B500F057FC214A044613780A2043F001031370137C43F001031374BC
+:4027000012F80A3C43F0020302F80A3C937943F00203937102F5AA521832137843F003031370144B18221A7013F8012C42F0400203F8012C13F8012C02F0FC0203F8012CBE
+:40274000CE2203F8062CA3F597530222123B1A70094A137843F00803137000F0C1FA074B08222046BDE810401A6000F019BC00BFAB43004006590040275B004080E200E0CF
+:4027800008B500F009FC0F4A137803F0FE031370A2F5AA52153A137803F0FE031370137C03F0FE03137412F80A3C03F0FD0302F80A3C937903F0FD039371BDE8084000F0BB
+:4027C000EFBB00BF00590040044A137803F03F0343EA8010C0B21070704700BF00590040082804D00A280CBF8223C22300E0422308380E4AC0B20428137098BF0C4B4FF095
+:40280000000298BF33F910100A4B88BF11461A8042F210734B4341F2883103F6C41393FBF1F305490B60054B1A80704702590040AE3B00005693FF1F5C93FF1F5493FF1FFC
+:4028400008B5102000F014F90721032000F090FA0749032000F07EFA064A0C20137843F006031370FFF7BCFF034B00221A8008BD39290000015900405893FF1F10B5054C6D
+:4028800023781BB9FFF7DCFF01232370BDE81040FFF728BF7C92FF1F044B1A7802F0FB021A701A7842F001021A7070470059004010B5084B1C7814F0010403D10028F9D0AE
+:4028C000002404E0204600F00BFA024B1B78204610BD00BF01590040034A044B1B881088181A00B2704700BF5493FF1FA05B00400E4A13881BB223B111880A2309B25943E7
+:4029000001E00B4B19680B4B1B88C01A42F2107300B203FB00F2022391FBF3F30028D8BF5B42134493FBF1F000B270475693FF1F5C93FF1F5893FF1F70470000014B1870E9
+:40294000704700BF7B640040014B1870704700BF7F640040014B1870704700BF7C640040014B1870704700BF7E640040F7B516461F460B4C00230325019300930A460146B2
+:402980002846257000F022F93A463146207800F0DDF80221207800F0C7F8207803B0F0BDE080FF1FF7B516461F460B4C00230225019300930A4601462846257000F006F917
+:4029C0003A463146207800F0C1F82946207800F0ABF8207803B0F0BDE180FF1FF7B516461F460B4C00230125019300930A4601462846257000F0EAF83A463146207800F06F
+:402A0000A5F80221207800F08FF8207803B0F0BDE280FF1F73B515461E460B4C0023019300930A4601461846237000F0CFF832462946207800F08AF80221207800F074F880
+:402A4000207802B070BD00BFE380FF1F024B1878C0F38010704700BF8F450040034A00F0F800137803431370704700BF02410040034A00F0F800137803431370704700BF74
+:402A800006410040074A7F23802113705170064A013BDBB202F80839002BF9D1034A1370704700BFE480FF1FF87B00400078004017280FD8084B0001C25C11B142F020028D
+:402AC00001E002F0DF02C254C25C42F00102C25400207047012070471070004017280BD8064B0001C25C02F0FE02C254C25C02F0DF02C25400207047012070471070004024
+:402B000017280DD8074900010B4603441A7942F004021A71435C43F00103435400207047012070471070004017280BD8064A0001835C490003F0F10301F00E0119438154A3
+:402B400000207047012070471070004041F6FF73994208BF4FF400519A4208BF4FF4005217289FBFC00000F1804000F5EC4081809ABFC280002001207047000017289FBF6F
+:402B8000034B00011954002088BF0120704700BF1970004017289FBF054B00011A5C01F007019DBF1143195400200120704700BF1470004017289FBF034B0001185C00F04D
+:402BC000070088BFFF20704714700040172810B51AD8C00001F07F0100F1804441EAC21204F5EC44D2B222709DF8082003F00F0343EA0213DBB263709DF80C30002003F08B
+:402C00000F03A370E07010BD012010BD10B500F0C3F90A4A5378182B0AD91478013B5370E30003F1804303F5F0431B78137000E0FF2400F0B5F9204610BD00BFE480FF1F33
+:402C4000030610B5044611D400F0A6F9084AE300117803F1804303F5F04319705378147001335370BDE8104000F09AB910BD00BFE480FF1F30B504060CD411F4704509D1B0
+:402C8000C40004F1804404F5F0442180A270E370284630BD012030BD03065FBFC00000F1804000F5F04081805ABFC280002001207047000038B50446084DB4F5004F05D988
+:402CC000286800F061F9A4F50044F6E7034B58686043BDE8384000F057B900BFEC80FF1F024B1B7A584300F04FB900BFEC80FF1F0E4B00F003001A78490102F0FC02104300
+:402D000018701A7801F0600142F080021A701A7802F07F021A701A7802F09F020A431A701A7842F010021A70704700BF83430040014B01221A70704784430040044B00F08C
+:402D40000F021B6853F8220043F82210704700BF08ED00E0054A00F01F00126800F1100352F8230042F82310704700BF08ED00E000F01F0000F16040490100F56440C9B29B
+:402D8000017070470F4B10B50F4900240F205C609C60DC601C615C61FFF7D0FF0B4A136843F0040313600A4B4FF47A72DB68B3FBF2F3084A1360084B4FF400421C60C3F883
+:402DC000E82010BD8092FF1F312E000010E000E0EC80FF1F14E000E018E000E0024A136843F002031360704710E000E008B5FFF7F5FF034A136843F00103136008BD00BFD3
+:402E000010E000E010B5054CA3691BB9FFF7BAFF0123A361BDE81040FFF7E8BF8092FF1F024B1868C0F30040704700BF10E000E038B5FFF7F5FF012808D1054D002455F891
+:402E4000243003B198470134052CF8D138BD00BF8492FF1F024B03EB80035868596070478092FF1F134B144A1B78DBB20360127843EA0223114A0360127843EA0243104A07
+:402E80000360127843EA026303600E4B0E4A1B78DBB24360127843EA02230C4A4360127843EA02430A4A4360127843EA02634360704700BF0301004904010049EC460040B2
+:402EC000020100490101004900010049050100490601004900000000FEB5494652465B460EB40746244909688A46244A12682448022100F071F8030020480068C018204936
+:402F000000F06AF8143883460121C9430C460125002600F041F8814651460B7823400B705846013000F030F83800F04028400B78234003430B70584600F026F80136072E00
+:402F4000F2D9002001300138013001200B78234003430B705846043000F016F8484600F01FF800BF00BF00BF0EBC894692469B46FEBD00BFAFF30080D480FF1FF880FF1F6B
+:402F800000C20100000000000230800803D000BF01380046FCD17047EFF3108072B6704780F31088704700BF094A137803F00303012B0AD0022B09D113790C2103F07F021C
+:402FC000044B01FB02339B7A00E013790020704700600040D492FF1F002902D0B0FBF1F0704708B14FF0FF3000F008B80029F8D00246B0FBF1F000FB11217047704700BFA1
+:40300000014B1868704700BF5C81FF1F0E4B70B51E460E4C0025E41AA410A54204D056F8253098470135F8E700F04EFE084B094C1E46E41AA4100025A54204D056F8253071
+:4030400098470135F8E770BDD43C0000D43C0000D43C0000DC3C000003460244934202D003F8011BFAE7704730B5141E05469BB0184604DA8B232B604FF0FF301DE04FF432
+:403080000273ADF80C300CBF234604F1FF33029305934FF6FF7300910491ADF80E3002461E9B6946284600F073F8431CBCBF8B232B6014B1009B00221A701BB030BD000022
+:4030C00007B5009313460A46014603480068FFF7CBFF03B05DF804FB5C81FF1F2DE9F0478E6882469E420C46914698463ED88A8912F4906F3AD02568096902236F1A656977
+:4031000005EB450595FBF3F57B1C43449D4238BF1D4653050FD5294600F04AFB064698B13A46216900F0D2FAA38923F4906343F08003A38113E02A4600F098FB064670B9E0
+:403140002169504600F0E8FA0C23CAF80030A3894FF0FF3043F04003A381BDE8F08726613E44266046466561ED1BA560464528BF464649463246206800F0B3FAA3680020A9
+:403180009B1BA36023681E442660BDE8F08700002DE9F04F9DB003938B8980461C060D4616460DD50B695BB9402100F001FB2860286118B90C23C8F80030CDE040236B6150
+:4031C0000023099320238DF82930DFF89CB130238DF82A3037463C4614F8013B1BB9B7EB060910D003E0252BF9D02746F3E74B46324629464046FFF771FF013000F0A780FE
+:40320000099B4B4409933B78002B00F0A08000234FF0FF3204930793059206938DF853301A930126052221784E4800F041FA671C049B38B14B4A3C46801A06FA00F0184379
+:403240000490EFE7D90644BF20228DF853201A0744BF2B228DF8532022782A2A03D0079A00210A200BE0039A111D12680391002A10DA524243F00200079204900BE027468C
+:403280003B780134303B092B03D800FB02320121F5E701B107923B782E2B1ED17B782A2B0AD1039B02371A1D1B680392002BB8BF4FF0FF33059310E0002319460593781CA7
+:4032C0000A2407463A780130303A092A03D804FB01210123F5E703B1059103223978224800F0E6F940B14023CBEB000003FA00F0049B013718430490397806221B487E1CEB
+:403300008DF8281000F0D4F988B1194B33B9039B073323F007030833039314E003AB00932A46144B04A94046AFF3008007E003AB00932A460F4B04A9404600F093F8B0F12A
+:40334000FF3F824603D0099B5344099342E7AB895B0601D4099801E04FF0FF301DB0BDE8F08F00BFA33C0000A93C0000AD3C000000000000DD3000002DE9F04791461F4627
+:403380000A698B6806469342B8BF1346C9F8003091F843200C46DDF8208012B10133C9F800302368990642BFD9F800300233C9F80030256815F0060510D104F1190A07E05B
+:4033C0000123524639463046C04701301AD00135E368D9F800209B1A9D42F1DB94F843302268003318BF012392060FD5E118302081F843005A1C94F845102244023382F884
+:40340000431003E04FF0FF30BDE8F08704F1430239463046C0470130F4D02268D9F80050E36802F00602042A08BF5D1B2269A3680CBF25EAE57500259342C4BF9B1AED1843
+:403440004FF000091A344D4509D00123224639463046C0470130D5D009F10109F3E70020BDE8F0872DE9F04317460A7E85B06E2A984606460C460C9B01F1430E00F0AE8054
+:4034800011D8632A22D009D8002A00F0BB80582A40F0CA8081F84520834955E0642A1ED0692A1CD0C0E0732A00F0B08009D86F2A2ED0702A40F0B8800A6842F020020A6091
+:4034C0003EE0752A24D0782A3AD0ADE01A6801F14205111D1960136884F84230A8E021681A6811F0800F02D0111D196008E011F0400F02F10401196002D0B2F9003000E045
+:403500001368002B3CDA2D225B4284F8432037E021681A6811F0800F02D0111D196007E011F0400F02F10401196001D0138800E01368227E5C496F2A14BF0A2208221BE068
+:4035400078225A4984F845202268186812F0800F00F104051D6003D1550601D5038800E00368D00744BF42F0200222601BB9226822F0200222601022002084F8430001E08A
+:4035800049490A226568002DA56008DB206820F0040020602BB9002D7DD175460CE0002B79D07546B3FBF2F002FB1033CB5C05F8013D03460028F5D1082A0BD12368DA0737
+:4035C00008D5236962689A42DEBF302305F8013C05F1FF35C5EB0E0323612EE008681A6810F0800F496903D0101D1860136808E010F0400F02F104001860136801D0198064
+:4036000000E0196000232361754616E01A68111D1960156800216268284600F049F808B1401B6060636804E004F1420584F8422001232361002384F84330CDF800803B468C
+:4036400003AA21463046FFF797FE013002D14FF0FF3026E023692A4639463046C0470130F5D023689B0710D5002504F1190907E001234A4639463046C0470130E7D00135CC
+:40368000E368039A9B1A9D42F2DBE068039B9842B8BF184605E00B7804F1420584F842308AE705B0BDE8F083923B0000B43C000010B5C9B202449042034605D01C78013064
+:4036C0008C42F8D1184610BD002010BD10B5431E0A44914204D011F8014B03F8014FF8E710BD884210B501EB020301D8421E0BE09842FBD28118D21AD34204D013F8014DA2
+:4037000001F8014DF8E710BD994204D011F8014B02F8014FF8E710BD38B50546002944D051F8043C0C1F002BB8BFE41800F0D4F81E4A1368114613B96360146030E0A342E7
+:403740000DD92268A018834201BF18685B681218226063600C6023E0A24203D813465A68002AF9D118681918A1420BD12168014458188242196013D11068526801441960EE
+:403780005A600DE002D90C232B6009E021686018824201BF106852680918216062605C602846BDE8384000F098B838BDA092FF1F70B5CD1C25F0030508350C2D38BF0C2534
+:4037C000002D064601DBA94202D90C23336046E000F082F8234B1C681A462146A1B10B685B1B0ED40B2B03D90B60CC18CD501EE08C420BBF63684B681360636018BF0C4695
+:4038000015E00C464968E9E7174C23681BB9304600F052F820602946304600F04DF8431C18D0C41C24F00304A0420DD12560304600F053F804F10B00231D20F00700C31A48
+:403840000ED05A42E25070BD211A304600F034F80130EBD10C233360304600F03EF8002070BD00BFA092FF1F9C92FF1FF8B5074615460E4621B91146BDE8F840FFF798BFAB
+:403880001AB9FFF749FF2846F8BD00F027F885420ED929463846FFF78BFF044650B131462A46FFF713FF31463846FFF735FF01E03046F8BD2046F8BD38B5064C002305467D
+:4038C00008462360FDF7F4FB431C02D1236803B12B6038BD8493FF1F7047704751F8040C0028BEBF091851F8043CC0180438704700000000050209020B020D020F021102BB
+:403900001302150228000000000104000100000000000000000157494E55534200003030303031000000000000000000E0000000000105000100D6000000070000002A0075
+:4039400044006500760069006300650049006E0074006500720066006100630065004700550049004400730000009E0000007B00330064003200370035006300660065004E
+:403980002D0035003400330035002D0034006400640035002D0061006300630061002D003900660062003900390035006500320066003600330038007D0000007B00330058
+:4039C00064003200370035006300660065002D0035003400330035002D0034006400640035002D0061006300630061002D00390066006200390039003500650032006600B4
+:403A00003600330038007D00000000007265706C792030782530327800686F6D696E6700626567696E6E696E67207365656B2066726F6D20256420746F2025640066696E14
+:403A40006973686564207365656B00796573006E6F0057616974696E6720666F72205553422E2E2E00555342207265616479005363616E6E696E67206472697665732E2E1C
+:403A80002E00647269766520303A20257320647269766520313A20257300636F6D6D616E6420307825303278006661696C2025642B25642B2564203D3D2025642C206E6F40
+:403AC00074202564007061737365643D256400756E64657272756E206166746572202564207061636B65747300636F756E743D256420693D256420643D256400636D645FEF
+:403B0000777269746500703D25642063723D25642063773D256420663D256420773D256420696E6465783D256420756E64657272756E3D256400756E64657272756E210015
+:403B4000737563636573730073746172742065726173696E670073746F702065726173696E670069646C650000510040100040510040300000000140001000140140000858
+:403B800000400140000A004C01400002005001402000303132333435363738394142434445460000000100000004000000100001000000040000001001000000C03B000072
+:403BC000010000008F3C0000000000000000000001000000D83B000001000000613C000004000000FA3B0000000000000000000000000000F83B0000FF0000000102400099
+:403C0000FF00000082024000FF00000003034000FF00000084034000FF00020304030904160346006C007500780045006E00670069006E0065002A0343006F0077006C00CE
+:403C4000610072006B00200054006500630068006E006F006C006F0067006900650073000009022E0001010080320904000004FF00000107050102400000070582024000E5
+:403C8000000705030340000A0705840340000A12010002FF0001080912006E0100020180014300232D302B2000686C4C00656667454647003031323334353637383961629E
+:403CC0006364656600000000F8B500BFF8BC08BC9E467047590000002D110000F8B500BFF8BC08BC9E46704735000000003D0000C880FF1F980000002812000000000000F3
+:403D0000000000008893FF1FFFFF0000675000400C00000007000000FFFFFFFF7F8000003F0000000000007D00FA0000400000000090D003000000000000000000000000EE
+:403D40000000000000000000000000000000000000000000A13C00000000000000000000000000000000000000000000000000000000000000000000000000000000000066
+:403D80000000000000000000000000000000000000000000FC80FF1F0000000000000000000000000000000000000000000000000000000000000000000000000000000069
 :403DC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C3
 :403E00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000082
 :403E40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042
@@ -4098,48 +4098,48 @@
 :40FF80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041
 :40FFC0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
 :0200000480007A
-:4000000001450040075200400564004002030140030501400107014006090140500A01404B0B0140270C0140510D01404B0E0140330F01400115014003170140161801404D
-:4000400025190140041B0140094001400A4101400E42014005430140044401401645014006460140094701400848014005490140164C0140034D01400550014003510140AF
-:400080007E020806094410861115600B610E7C402C802D0A3A803C7E7E01E202EE02E201E621EC02EE02964099209D40A140A220EE020201050107060D040E010F01130742
-:4000C0001501170219071C0228042F07300132043307340238023B083E1540654104430145044602475E483549FF4AFF4BFF4D204EF051105608580459045A045B045C9002
-:400100005D995F0161086280630C64406540664067A8684069A86B086D08800281018205860F880F8A208C0F8E1096409C029E34A001A20AA480AC40AF01B007B101B2C048
-:40014000B638B902BA02BF01D804D904DB04DC09DF010002014005010604072209800E22100816501740188019201A201D011E221F09210C25012B022D40311032053908BC
-:400180003A403C024201430249144B485080520A582059405E406180630468096D807C207E08804081018B049140920B9340948095089620970A99109A549B629D05A2205A
-:4001C000A302A480A508A602A708AA10AC80B380C0F9C2A1C4B2CA18CC07CE8AD009D20CD61CD80CE620EC04810188058A0A8C02900B96049A029C029E0DA002B008B40797
-:40020000B601B701BE41BF40C041C720C820C9FFCAFFCBFFCD20CEF0D110D608D804D904DA04DB04DC09DD99DF01E108E240E340E480E640E74001200202050106010720D3
-:4002400009080A820B080D200EA00F0110801711184019301A011D201F60200125C02648272A2F213608371138023D803E103F2040414560460447084E0850015601571050
-:4002800058A05E105F8062706680670569406F01831087048B408C01928A934094809508970898209B509D149ED09F20A210A302A480A5A8A622A708AA40B020B440C0B326
-:4002C000C2FFC458CA50CCE0CE11D079D220D63CD83CE004E804EE020080010402400410050808400A800B200C280D080F011007113112F8130A1420150418021C181D04E1
-:400300001EC1200628F829092A072B162D072E042F38303F313F34C03A203B03580459045B045C995D905F01808086408840890D8C018D708E329140940195019606980FB5
-:4003400099A09A209C0F9E10A004A209A705AA0FAB50AD0AB1C0B207B30CB4C0B503B638B730BA08D804D90BDB04DC99DF01016002D0040405400680070809080A820B0866
-:400380000DA00E2010841203172119201A881B021C041D401E201F20220123402440251026082759280429102B022E802F283080310432013628370139483A113C403D20D8
-:4003C00069406E407E80C0FFC2EFC45BCA7CCCEBCE3FDE80EA04E280EA02EE040D021901330237013F4459045B045F01850191029C01B001B102B501BE01BF11D608D80435
-:40040000D904DB04DD90DF0109801A4022012308268027103002362038083D8058205A805C405D206008618068026C046F0285408A818C488F10964099209D40A140A220CF
-:40044000C201CC21CE12D63CD80CE280E608EA02EE04AB02B420B640B70817043304340236803B443D80C420CCE0CE703380372085409744A540A680AC02CC30E240EE409B
-:4004800050085710800883108B0497449F20A6C0A780AE40D460E280E680EC409F20A6C0A780AF40EE4014407380C404DC01500A56405D8062086640670280028A088F2038
-:4004C00097209980A980AF10B040B780D407D605D802E002E401EA01EC089720A320A408AB01B008EE040B220E800F049720A320A408A640AE40C20F26408A80A6C0AB80D1
-:40050000AF20C820EA40EE2077109B10AB10DE20EA20041008080C080F02508057205E80620187018A408E01A320A408AB01AF04C001C20DD406D604D802E004E402B49823
-:40054000EA0AEC0201010D010F0111011D0100BD012A10050200000019006200000000001017002803400C02104828150300740480000000000001000063001C10004000CF
-:40058000000000010000000F7F3080702008000000004010260103000000E04028FFFFFF0020F00120100100000018000404040499990001000800004020800840200008B0
-:4005C000000040A8000000000000000000000000000000003F00003F1F001F000000000000000000100000004000000000000000C0000000FF0020FF47004700000100009A
-:40060000A00000BFBF009F000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FC
-:40064000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007A
-:40068000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003A
-:4006C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FA
-:4007000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B9
-:400740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000079
-:400780000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039
-:4007C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F9
-:4008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B8
-:400840000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000078
-:400880000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000038
-:4008C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F8
-:4009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B7
-:400940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000077
-:400980000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000037
-:4009C00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F7
-:400A000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B6
-:400A40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000076
+:400000000145004008520040015B004001650040020101402C0201402D0301400F0501400B0701406308014056090140570A01404A0B0140500C01404A0D0140480E014042
+:40004000390F01400415014004170140671801404B190140361A0140471B01400D40014010410140134201400D43014004440140064501400A460140084701400B48014097
+:4000800010490140144C01400C4D014006500140045101407E02080109441180180219016009610A7C402721290AE204E6080F011001150126012E012F013001310138026A
+:4000C00039023E013F01580459045B045F01810883048C018D0E910194029701A404AD04AE04AF0AB004B102B301B402B50CB601B802B908BE51BF04D608D804D909DB0401
+:40010000DC90DD90DF01020208080C02100213081540170818081A801B801C80200821012210231026012A802C02300233043708388039023D405840600268026B0C6D4004
+:40014000782088028B109840B040C001C214C4A5CA18CC43CE19D608D808DE04E208E68080088201928094809C289E80A201A602B044B380B404B610E604EA01EE44804068
+:40018000842094809C209E80A602AA40E211E608EA01EE0C00800121020403020403052106FC0704080109210A020B080C040E100F4010FF11011404152F162019201A0495
+:4001C0001B011C041D211EF91F0E220224042608271028042A402B2F2D0F2E02311F336034FF39083A0C3E104003450C470E481149FF4AFF4BFF50045609581859045A044E
+:400200005B045C995D995F0162C081028407850186388702880189048C028D048E04902091049208940895029610983F99029C089D049E30A105A503A704A802A902AA0417
+:40024000AC3FAD02B43FB507B63FBF10D608D804D904DB04DC09DD90DF010010010803010490050909240A420C030E020F24100A15081602172119401A021B501E101F107B
+:400280002120242025052603272029982B402C022F18300831803202332035983701388039013B183C803D113E0447084F0856085A805F4062806302670269806B026C0881
+:4002C0006D116E846F21759076467F01814087018E08908094209581971499049C019DC99E449F03A382A408A682A729C0F7C2FFC4F3CA7FCCFFCEFFD040D618D818DE1080
+:40030000E210EA01EE0C0101041205010624084209800A100B200C040D700F80107011081201130414061508170219071A081B081D801E601F102140221023802404250F16
+:4003400027F028042B0F2C802D01300F320F348035FF3670380A3B0C3E103F105804590A5B045C995F01824185F186418704888089208A018B118CF18E0291F1924E930218
+:40038000954096419711980199109A149BE19F0EA1F1A308A580A641A711A801AA28B00FB10FB3F0B4F0BA02BB02D80BD90BDB04DC99DF010108020203080510076208017B
+:4003C00009200A220D020E1410021240131414081508188819041A221B821C801D121F1021282501277029892B082D022F103008314033213608376238A039013A043E1454
+:4004000068026D407A107E80800481408D108F019108921495809702980899029D109F72A218A440A509A701A809B340B408B502B640C0F7C27FC46FCACFCCFFCE6FDE8298
+:40044000E401E8F0EC20EE40020103C4070808050A020B040C380D200F82101011C7120813181602170418081A301B041F302520274128042B042C062E012F043020320715
+:40048000330F341837F43B083E04580459085B045C995F0182108303840285628604870489208A108B508DFC8E108F0192039420964097809A109B1C9C409E209F10A07C22
+:4004C000A162A201A308A61CA710A940AA10AB30AC02AE08AF10B01FB11FB360B460B780D808D908DC99DF0100A001800204036004020706081009080A800B010C080E8878
+:400500001218134215401608180419201A841B201C081EA02105220923112504268429922A242D802E102F20301031083350340136883722380439823B103D0A3E203F4070
+:40054000611062106D406F047B037F028A08900292509508968297129C019D329F62A018A444A501A690A721C0DFC27FC4CFCA7FCCFECEFFDE18E020E208EA8000020120A4
+:40058000024803C004C20502062407440A030B900E9011FC129013011690170318201AC01B901E901F9020FC21C222012328269027902A9C2B9C2F90321F331F34E037E015
+:4005C0003A203B80420647E0482049FF4AFF4BFF4F83580859085A045B045C995D095F0180E28208861088E28A049210942096D09A03A0FCA201A440A630A880AA30AE1C91
+:40060000B2E0B41FD808DB04DC09DF01009001C6032005260610072009010A140B420D200E100F40121013121548171218101A241B101C201D201E101F0820022204230148
+:4006400029862B08300131103204335039043B1148054A0252015AAA6120628263206A406C097B037F0282018610C07FC27FC4FECA0FCC0FCE07D204D60FD80FDE188A02E6
+:40068000A602E604EE02A602B680E401EE020010022003020406063807040802090C0A040BF10C080D0C0F20100813081408150C17101808190C1B401C081F0221802204B3
+:4006C000230C250327FC281A29012A202B022DFF2E01303F31FF3E013F01580459045B045F0181238280830C842286CC870188308A028B2F8CC88D0F9123924894C8952367
+:40070000970898D499239B049CC89F10A0C8A120A302A4C8A52FA802AB40AC80AE01B080B261B31FB41FB560B760B808B9A0BE11C046C620C808C9FFCAFFCBFFCD20CEF004
+:40074000D110D804D904DA04DB04DC99DD09DF01E108E240E340E480E640E7400010010803820490050909080A420B040E020F941002110A120415401721184019181C80B4
+:40078000218C2314274029182A022D4A2F0830083361350436413720381039413A043D013F9440404A085010584059205F806C026D4082409080910192029410950896C023
+:4007C000971C99049A069B219D099F08A008A105A2C1A3E6A442A580A708B340B610C0FFC2FFC4DFCAF7CCFFCEFFD001D204D61CEE120008060209020D01100411041202D8
+:4008000018041F04220428012C063006310132013302340835043A023E143F055608580459045B045C995D905F0181028405881090019236930198019C319E0AAC05AD012B
+:40084000B00CB102B210B420B501B603BE04BF11D608D804D904DB04DC09DD90DF0101080240051809200A400E820F08100811401280154019231A501C101D101E821F0E2C
+:4008800020402120220827882F02300232803601382039803F0158205A805F40600862406701680869806F0180408210844887408B018E4090209140941096409708982064
+:4008C00099089C409D239F88A002A280A304A608A708B020B410C06CC2DAC48BCA10CC89CE8CD61CD81CE001E622EE021B011F083140330836843B4083408540C630CCF07B
+:40090000CE10E220E61030803204364037043A083F80848088029740A340A604AE80AF01CCF0CE60E2105004570880049002960897409A049E089F04A002A120A644A80182
+:40094000AA04B520D460E680EA80EE208E08900297409A049E08A002A120A640AA04AB0CAE04EA80EEB014407008C404DC0160808740A408B040D802EA011B0482209780E6
+:400980009940B008B140B480C608E809EC040B880F4197899940A220AB05AF04C20F24088004900297409A04A002A120AE40C820E480EE4050015120560470027F018301EC
+:4009C00090029A04A002A120AF40D4E0DC80DE20E620EE40070208080D010E021F10520854085940622095029940A220AF40B101C001C20DC601D407D802EA04800887021E
+:400A00008E019B02A201A408AF10B008B608E208EA01EC02010109010D010F0111011D0100FF01AB02021105BF0000A09F001F0000000000000000001000000040000000B7
+:400A400000000000C0000000FF0000B84700470000010000800000008000800000000000000707000700000027001801270018010004000000050000000000000000000052
 :400A80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036
 :400AC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F6
 :400B000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B5
@@ -4615,12 +4615,12 @@
 :0200000490105A
 :04000000BC90ACAF55
 :0200000490303A
-:0200000033F2D9
+:0200000021B02D
 :0200000490402A
 :4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C0
 :400040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080
 :400080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040
 :4000C0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 :0200000490501A
-:0C00000000012E16106900002E2A445B3F
+:0C00000000012E16106900002E3032198D
 :00000001FF

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,6 +28,54 @@
         <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" />
@@ -147,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" />
@@ -170,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" />
@@ -241,6 +360,53 @@
         <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" />
@@ -288,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" />
@@ -312,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" />
@@ -600,54 +814,69 @@
   </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_v5_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" />
@@ -3737,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" />
@@ -3752,6 +3986,11 @@
         <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" />
@@ -3833,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" />
@@ -3859,6 +4103,32 @@
         <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" />
@@ -3892,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">
@@ -3912,9 +4187,14 @@
         <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="2,5" />
+        <Data key="Port Format" value="12,7" />
       </Group>
     </Group>
     <Group key="fede1767-f3fd-4021-b3d7-8f9d88f36f9b">

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,40 +1,300 @@
-PACKAGES = zlib sqlite3 libusb-1.0
-
-export CFLAGS = -O3 -g --std=c++14 \
-	-ffunction-sections -fdata-sections
-export LDFLAGS = -O3
+#Special Windows settings.
 
 ifeq ($(OS), Windows_NT)
-export CXX = /mingw32/bin/g++
-export AR = /mingw32/bin/ar rcs
-export STRIP = /mingw32/bin/strip
-export CFLAGS += -I/mingw32/include/libusb-1.0
-export LDFLAGS +=
-export LIBS = -static -lz -lsqlite3 -lusb-1.0
-export EXTENSION = .exe
-else
-export CXX = g++
-export AR = ar rcs
-export STRIP = strip
-export CFLAGS += $(shell pkg-config --cflags $(PACKAGES))
-export LDFLAGS +=
-export LIBS = $(shell pkg-config --libs $(PACKAGES))
-export EXTENSION =
+	MINGWBIN = /mingw32/bin
+	CCPREFIX = $(MINGWBIN)/
+	LUA = $(MINGWBIN)/lua
+	PKG_CONFIG = $(MINGWBIN)/pkg-config
+	WX_CONFIG = /usr/bin/sh $(MINGWBIN)/wx-config --static=yes
+	PROTOC = $(MINGWBIN)/protoc
+	PLATFORM = WINDOWS
+	LDFLAGS += \
+		-static
+	CXXFLAGS += \
+		-std=c++17 \
+		-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)
+	EXT ?= .exe
 endif
 
-CFLAGS += -Ilib -Idep/fmt -Iarch
+#Special OSX settings.
 
-export OBJDIR = .obj
+ifeq ($(shell uname),Darwin)
+	PLATFORM = OSX
+	LDFLAGS += \
+		-framework IOKit \
+		-framework Foundation
+endif
 
-all: .obj/build.ninja
-	@ninja -f .obj/build.ninja -v
+#Check the Make version.
+
+
+ifeq ($(findstring 4.,$(MAKE_VERSION)),)
+$(error You need GNU Make 4.x for this (if you're on OSX, use gmake).)
+endif
+
+#Normal settings.
+
+OBJDIR ?= .obj
+CCPREFIX ?=
+LUA ?= lua
+CC ?= $(CCPREFIX)gcc
+CXX ?= $(CCPREFIX)g++
+AR ?= $(CCPREFIX)ar
+PKG_CONFIG ?= pkg-config
+WX_CONFIG ?= wx-config
+PROTOC ?= protoc
+CFLAGS ?= -g -O3
+CXXFLAGS += -std=c++17
+LDFLAGS ?=
+PLATFORM ?= UNIX
+TESTS ?= yes
+EXT ?=
+DESTDIR ?=
+PREFIX ?= /usr/local
+BINDIR ?= $(PREFIX)/bin
+
+CFLAGS += \
+	-Iarch \
+	-Ilib \
+	-I. \
+	-I$(OBJDIR)/arch \
+	-I$(OBJDIR)/lib \
+	-I$(OBJDIR) \
+	-Wno-deprecated-declarations \
+
+LDFLAGS += \
+	-lz \
+	-lfmt
+
+.SUFFIXES:
+.DELETE_ON_ERROR:
+
+define nl
+
+endef
+
+empty :=
+space := $(empty) $(empty)
+
+use-library = $(eval $(use-library-impl))
+define use-library-impl
+$1: $(call $3_LIB)
+$1: private LDFLAGS += $(call $3_LDFLAGS)
+$2: private CFLAGS += $(call $3_CFLAGS)
+endef
+
+use-pkgconfig = $(eval $(use-pkgconfig-impl))
+define use-pkgconfig-impl
+ifneq ($(strip $(shell $(PKG_CONFIG) $3; echo $$?)),0)
+$$(error Missing required pkg-config dependency: $3)
+endif
+
+$(1): private LDFLAGS += $(shell $(PKG_CONFIG) --libs $(3))
+$(2): private CFLAGS += $(shell $(PKG_CONFIG) --cflags $(3))
+endef
+
+.PHONY: all binaries tests clean install install-bin
+all: binaries tests docs
+
+PROTOS = \
+	arch/aeslanier/aeslanier.proto \
+	arch/agat/agat.proto \
+	arch/amiga/amiga.proto \
+	arch/apple2/apple2.proto \
+	arch/brother/brother.proto \
+	arch/c64/c64.proto \
+	arch/f85/f85.proto \
+	arch/fb100/fb100.proto \
+	arch/ibm/ibm.proto \
+	arch/macintosh/macintosh.proto \
+	arch/micropolis/micropolis.proto \
+	arch/mx/mx.proto \
+	arch/northstar/northstar.proto \
+	arch/rolandd20/rolandd20.proto \
+	arch/smaky6/smaky6.proto \
+	arch/tids990/tids990.proto \
+	arch/victor9k/victor9k.proto \
+	arch/zilogmcz/zilogmcz.proto \
+	lib/common.proto \
+	lib/config.proto \
+	lib/decoders/decoders.proto \
+	lib/drive.proto \
+	lib/encoders/encoders.proto \
+	lib/fl2.proto \
+	lib/fluxsink/fluxsink.proto \
+	lib/fluxsource/fluxsource.proto \
+	lib/imagereader/imagereader.proto \
+	lib/imagewriter/imagewriter.proto \
+	lib/layout.proto \
+	lib/usb/usb.proto \
+	lib/vfs/vfs.proto \
+	tests/testproto.proto \
+
+PROTO_HDRS = $(patsubst %.proto, $(OBJDIR)/%.pb.h, $(PROTOS))
+PROTO_SRCS = $(patsubst %.proto, $(OBJDIR)/%.pb.cc, $(PROTOS))
+PROTO_OBJS = $(patsubst %.cc, %.o, $(PROTO_SRCS))
+PROTO_CFLAGS = $(shell $(PKG_CONFIG) --cflags protobuf)
+$(PROTO_SRCS): | $(PROTO_HDRS)
+$(PROTO_OBJS): CFLAGS += $(PROTO_CFLAGS)
+PROTO_LIB = $(OBJDIR)/libproto.a
+$(PROTO_LIB): $(PROTO_OBJS)
+PROTO_LDFLAGS = $(shell $(PKG_CONFIG) --libs protobuf) -pthread
+.PRECIOUS: $(PROTO_HDRS) $(PROTO_SRCS)
+
+include dep/agg/build.mk
+include dep/libusbp/build.mk
+include dep/stb/build.mk
+include dep/emu/build.mk
+include dep/fatfs/build.mk
+include dep/adflib/build.mk
+include dep/hfsutils/build.mk
+include scripts/build.mk
+
+include lib/build.mk
+include arch/build.mk
+include src/build.mk
+include src/gui/build.mk
+include tools/build.mk
+include tests/build.mk
+
+do-encodedecodetest = $(eval $(do-encodedecodetest-impl))
+define do-encodedecodetest-impl
+
+tests: $(OBJDIR)/$1$$(subst $$(space),_,$3).flux.encodedecode
+$(OBJDIR)/$1$$(subst $$(space),_,$3).flux.encodedecode: scripts/encodedecodetest.sh $(FLUXENGINE_BIN) $2
+	@mkdir -p $(dir $$@)
+	@echo ENCODEDECODETEST $1 flux $(FLUXENGINE_BIN) $2 $3
+	@scripts/encodedecodetest.sh $1 flux $(FLUXENGINE_BIN) $2 $3 > $$@
+
+tests: $(OBJDIR)/$1$$(subst $$(space),_,$3).scp.encodedecode
+$(OBJDIR)/$1$$(subst $$(space),_,$3).scp.encodedecode: scripts/encodedecodetest.sh $(FLUXENGINE_BIN) $2
+	@mkdir -p $(dir $$@)
+	@echo ENCODEDECODETEST $1 scp $(FLUXENGINE_BIN) $2 $3
+	@scripts/encodedecodetest.sh $1 scp $(FLUXENGINE_BIN) $2 $3 > $$@
+
+endef
+
+$(call do-encodedecodetest,agat,,--drive.tpi=96)
+$(call do-encodedecodetest,amiga,,--drive.tpi=135)
+$(call do-encodedecodetest,apple2,,--140 --drive.tpi=96)
+$(call do-encodedecodetest,atarist,,--360 --drive.tpi=135)
+$(call do-encodedecodetest,atarist,,--370 --drive.tpi=135)
+$(call do-encodedecodetest,atarist,,--400 --drive.tpi=135)
+$(call do-encodedecodetest,atarist,,--410 --drive.tpi=135)
+$(call do-encodedecodetest,atarist,,--720 --drive.tpi=135)
+$(call do-encodedecodetest,atarist,,--740 --drive.tpi=135)
+$(call do-encodedecodetest,atarist,,--800 --drive.tpi=135)
+$(call do-encodedecodetest,atarist,,--820 --drive.tpi=135)
+$(call do-encodedecodetest,bk)
+$(call do-encodedecodetest,brother,,--120 --drive.tpi=135)
+$(call do-encodedecodetest,brother,,--240 --drive.tpi=135)
+$(call do-encodedecodetest,commodore,scripts/commodore1541_test.textpb,--171 --drive.tpi=96)
+$(call do-encodedecodetest,commodore,scripts/commodore1541_test.textpb,--192 --drive.tpi=96)
+$(call do-encodedecodetest,commodore,,--800 --drive.tpi=135)
+$(call do-encodedecodetest,commodore,,--1620 --drive.tpi=135)
+$(call do-encodedecodetest,hplif,,--264 --drive.tpi=135)
+$(call do-encodedecodetest,hplif,,--608 --drive.tpi=135)
+$(call do-encodedecodetest,hplif,,--616 --drive.tpi=135)
+$(call do-encodedecodetest,hplif,,--770 --drive.tpi=135)
+$(call do-encodedecodetest,ibm,,--1200 --drive.tpi=96)
+$(call do-encodedecodetest,ibm,,--1232 --drive.tpi=96)
+$(call do-encodedecodetest,ibm,,--1440 --drive.tpi=135)
+$(call do-encodedecodetest,ibm,,--1680 --drive.tpi=135)
+$(call do-encodedecodetest,ibm,,--180 --drive.tpi=96)
+$(call do-encodedecodetest,ibm,,--160 --drive.tpi=96)
+$(call do-encodedecodetest,ibm,,--320 --drive.tpi=96)
+$(call do-encodedecodetest,ibm,,--360 --drive.tpi=96)
+$(call do-encodedecodetest,ibm,,--720_96 --drive.tpi=96)
+$(call do-encodedecodetest,ibm,,--720_135 --drive.tpi=135)
+$(call do-encodedecodetest,mac,scripts/mac400_test.textpb,--400 --drive.tpi=135)
+$(call do-encodedecodetest,mac,scripts/mac800_test.textpb,--800 --drive.tpi=135)
+$(call do-encodedecodetest,n88basic,,--drive.tpi=96)
+$(call do-encodedecodetest,rx50,,--drive.tpi=96)
+$(call do-encodedecodetest,tids990,,--drive.tpi=48)
+$(call do-encodedecodetest,victor9k,,--612 --drive.tpi=96)
+$(call do-encodedecodetest,victor9k,,--1224 --drive.tpi=96)
+
+do-corpustest = $(eval $(do-corpustest-impl))
+define do-corpustest-impl
+
+tests: $(OBJDIR)/corpustest/$2
+$(OBJDIR)/corpustest/$2: $(FLUXENGINE_BIN) \
+		../fluxengine-testdata/data/$1 ../fluxengine-testdata/data/$2
+	@mkdir -p $(OBJDIR)/corpustest
+	@echo CORPUSTEST $1 $2 $3
+	@$(FLUXENGINE_BIN) read $3 -s ../fluxengine-testdata/data/$1 -o $$@ > $$@.log
+	@cmp $$@ ../fluxengine-testdata/data/$2
+
+endef
+
+ifneq ($(wildcard ../fluxengine-testdata/data),)
+
+$(call do-corpustest,amiga.flux,amiga.adf,amiga --drive.tpi=135)
+$(call do-corpustest,atarist360.flux,atarist360.st,atarist --360 --drive.tpi=135)
+$(call do-corpustest,atarist720.flux,atarist720.st,atarist --720 --drive.tpi=135)
+$(call do-corpustest,brother120.flux,brother120.img,brother --120 --drive.tpi=135)
+$(call do-corpustest,cmd-fd2000.flux,cmd-fd2000.img,commodore --1620 --drive.tpi=135)
+$(call do-corpustest,ibm1232.flux,ibm1232.img,ibm --1232 --drive.tpi=96)
+$(call do-corpustest,ibm1440.flux,ibm1440.img,ibm --1440 --drive.tpi=135)
+$(call do-corpustest,mac800.flux,mac800.dsk,mac --800 --drive.tpi=135)
+$(call do-corpustest,micropolis315.flux,micropolis315.img,micropolis --315 --drive.tpi=100)
+$(call do-corpustest,northstar87-synthetic.flux,northstar87-synthetic.nsi,northstar --87 --drive.tpi=48)
+$(call do-corpustest,northstar175-synthetic.flux,northstar175-synthetic.nsi,northstar --175 --drive.tpi=48)
+$(call do-corpustest,northstar350-synthetic.flux,northstar350-synthetic.nsi,northstar --350 --drive.tpi=48)
+$(call do-corpustest,victor9k_ss.flux,victor9k_ss.img,victor9k --612 --drive.tpi=96)
+$(call do-corpustest,victor9k_ds.flux,victor9k_ds.img,victor9k --1224 --drive.tpi=96)
+
+endif
+
+$(OBJDIR)/%.a:
+	@mkdir -p $(dir $@)
+	@echo AR $@
+	@$(AR) rc $@ $^
+
+%.exe:
+	@mkdir -p $(dir $@)
+	@echo LINK $@
+	@$(CXX) -o $@ $(filter %.o,$^) $(filter %.a,$^) $(LDFLAGS) $(filter %.a,$^) $(LDFLAGS)
+
+$(OBJDIR)/%.o: %.cpp
+	@mkdir -p $(dir $@)
+	@echo CXX $<
+	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+
+$(OBJDIR)/%.o: %.cc
+	@mkdir -p $(dir $@)
+	@echo CXX $<
+	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+
+$(OBJDIR)/%.o: $(OBJDIR)/%.cc
+	@mkdir -p $(dir $@)
+	@echo CXX $<
+	@$(CXX) $(CFLAGS) $(CXXFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+
+$(OBJDIR)/%.o: %.c
+	@mkdir -p $(dir $@)
+	@echo CC $<
+	@$(CC) $(CFLAGS) $(CFLAGS) -MMD -MP -MF $(@:.o=.d) -c -o $@ $<
+
+$(OBJDIR)/%.pb.h: %.proto
+	@mkdir -p $(dir $@)
+	@echo PROTOC $@
+	@$(PROTOC) -I. --cpp_out=$(OBJDIR) $<
 
 clean:
-	@echo CLEAN
-	@rm -rf $(OBJDIR)
+	rm -rf $(OBJDIR)
 
-.obj/build.ninja: mkninja.sh Makefile
-	@echo MKNINJA $@
-	@mkdir -p $(OBJDIR)
-	@sh $< > $@
+install: install-bin # install-man install-docs ...
 
+install-bin: fluxengine$(EXT) fluxengine-gui$(EXT) brother120tool$(EXT) brother240tool$(EXT) upgrade-flux-file$(EXT)
+	install -d "$(DESTDIR)$(BINDIR)"
+	for target in $^; do \
+		install $$target "$(DESTDIR)$(BINDIR)/$$target"; \
+	done
+
+-include $(OBJS:%.o=%.d)

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,17 +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.
-
-**Another important note.** On 2019-07-03 I've revamped the build process and
-the (command line) user interface. It should be much nicer now, not least in
-that there's a single client binary with all the functionality in it. The
-interface is a little different, but not much. The build process is now
-better (simpler). See [the building](doc/building.md) and
-[using](doc/using.md) pages for more details.
+**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?
 ------
@@ -59,56 +65,83 @@ 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
 
-  - [Troubleshooting dubious disks](doc/problems.md) ∾ it's not an exact science ∾
-    the sector map ∾ clock detection and the histogram
+  - [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 (or had reports from
-people who've had it 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)     |  🦄   |   🦄   |                                     |
-| [Brother FB-100](doc/disk-fb100.md)      |  🦖   |        | Tandy Model 100, Husky Hunter, knitting machines |
-| [Macintosh 800kB](doc/disk-macintosh.md) |  🦄   |        | and probably the 400kB too          |
-| [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 | 🦄 | 🦄 |  |
+| [`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 | 🦖 |  |  |
+| [`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  |
+| [`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 | 🦖 |  |  |
 {: .datatable }
 
-### Even older disk formats
-
-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" |
-| [DVK MX](doc/disk-mx.md)                 |  🦖   |        | Soviet PDP-11 clone |
-| [Victor 9000](doc/disk-victor9k.md)      |  🦖   |        | 8-inch        |
-| [Zilog MCZ](doc/disk-zilogmcz.md)        |  🦖   |        | 8-inch _and_ hard sectors |
-{: .datatable }
+<!-- FORMATSEND -->
 
 ### Notes
 
@@ -125,7 +158,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.
 
@@ -179,18 +212,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, Todd Miller and William A. Rowe (and probably others). It is licensed
+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

@@ -2,19 +2,10 @@
 #define AESLANIER_H
 
 #define AESLANIER_RECORD_SEPARATOR 0x55555122
-#define AESLANIER_SECTOR_LENGTH    256
-#define AESLANIER_RECORD_SIZE      (AESLANIER_SECTOR_LENGTH + 5)
+#define AESLANIER_SECTOR_LENGTH 256
+#define AESLANIER_RECORD_SIZE (AESLANIER_SECTOR_LENGTH + 5)
 
-class Sector;
-class Fluxmap;
-
-class AesLanierDecoder : public AbstractDecoder
-{
-public:
-    virtual ~AesLanierDecoder() {}
-
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-};
+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

@@ -6,60 +6,59 @@
 #include "decoders/fluxmapreader.h"
 #include "sector.h"
 #include "bytes.h"
-#include "record.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. */
+/* This is actually M2FM, rather than MFM, but it our MFM/FM decoder copes fine
+ * with it. */
 
-static Bytes reverse_bits(const Bytes& input)
+class AesLanierDecoder : public Decoder
 {
-    Bytes output;
-    ByteWriter bw(output);
-
-    for (uint8_t b : input)
-        bw.write_8(reverse_bits(b));
-    return output;
-}
-
-AbstractDecoder::RecordType AesLanierDecoder::advanceToNextRecord()
-{
-    _sector->clock = _fmr->seekToPattern(SECTOR_PATTERN);
-    if (_fmr->eof() || !_sector->clock)
-        return UNKNOWN_RECORD;
-    return SECTOR_RECORD;
-}
-
-void AesLanierDecoder::decodeSectorRecord()
-{
-    /* Skip ID mark. */
-
-    readRawBits(16);
-
-    const auto& rawbits = readRawBits(AESLANIER_RECORD_SIZE*16);
-    const auto& bytes = decodeFmMfm(rawbits).slice(0, AESLANIER_RECORD_SIZE);
-    const auto& reversed = reverse_bits(bytes);
-
-    _sector->logicalTrack = reversed[1];
-    _sector->logicalSide = 0;
-    _sector->logicalSector = reversed[2];
-
-    /* Check header 'checksum' (which seems far too simple to mean much). */
+public:
+    AesLanierDecoder(const DecoderProto& config): Decoder(config) {}
 
+    nanoseconds_t advanceToNextRecord() override
     {
-        uint8_t wanted = reversed[3];
-        uint8_t got = reversed[1] + reversed[2];
-        if (wanted != got)
-            return;
+        return seekToPattern(SECTOR_PATTERN);
     }
 
-    /* Check data checksum, which also includes the header and is
-        * significantly better. */
+    void decodeSectorRecord() override
+    {
+        /* Skip ID mark (we know it's a AESLANIER_RECORD_SEPARATOR). */
 
-    _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;
+        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 "globals.h"
+#include "decoders/decoders.h"
+#include "agat.h"
+#include "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 "globals.h"
+#include "decoders/decoders.h"
+#include "agat.h"
+#include "crc.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "sector.h"
+#include "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 "globals.h"
+#include "decoders/decoders.h"
+#include "amiga.h"
+#include "bytes.h"
+#include "fmt/format.h"
+
+uint32_t amigaChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint32_t checksum = 0;
+
+    assert((bytes.size() & 3) == 0);
+    while (!br.eof())
+        checksum ^= br.read_be32();
+
+    return checksum & 0x55555555;
+}
+
+static uint8_t everyother(uint16_t x)
+{
+    /* aabb ccdd eeff gghh */
+    x &= 0x6666; /* 0ab0 0cd0 0ef0 0gh0 */
+    x >>= 1;     /* 00ab 00cd 00ef 00gh */
+    x |= x << 2; /* abab cdcd efef ghgh */
+    x &= 0x3c3c; /* 00ab cd00 00ef gh00 */
+    x >>= 2;     /* 0000 abcd 0000 efgh */
+    x |= x >> 4; /* 0000 abcd abcd efgh */
+    return x;
+}
+
+Bytes amigaInterleave(const Bytes& input)
+{
+    Bytes output;
+    ByteWriter bw(output);
+
+    /* Write all odd bits. (Numbering starts at 0...) */
+
+    {
+        ByteReader br(input);
+        while (!br.eof())
+        {
+            uint16_t x = br.read_be16();
+            x &= 0xaaaa;       /* a0b0 c0d0 e0f0 g0h0 */
+            x |= x >> 1;       /* aabb ccdd eeff gghh */
+            x = everyother(x); /* 0000 0000 abcd efgh */
+            bw.write_8(x);
+        }
+    }
+
+    /* Write all even bits. */
+
+    {
+        ByteReader br(input);
+        while (!br.eof())
+        {
+            uint16_t x = br.read_be16();
+            x &= 0x5555;       /* 0a0b 0c0d 0e0f 0g0h */
+            x |= x << 1;       /* aabb ccdd eeff gghh */
+            x = everyother(x); /* 0000 0000 abcd efgh */
+            bw.write_8(x);
+        }
+    }
+
+    return output;
+}
+
+Bytes amigaDeinterleave(const uint8_t*& input, size_t len)
+{
+    assert(!(len & 1));
+    const uint8_t* odds = &input[0];
+    const uint8_t* evens = &input[len / 2];
+    Bytes output;
+    ByteWriter bw(output);
+
+    for (size_t i = 0; i < len / 2; i++)
+    {
+        uint8_t o = *odds++;
+        uint8_t e = *evens++;
+
+        /* This is the 'Interleave bits with 64-bit multiply' technique from
+         * http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
+         */
+        uint16_t result =
+            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL) *
+                     0x0102040810204081ULL >>
+                 49) &
+                0x5555) |
+            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL) *
+                     0x0102040810204081ULL >>
+                 48) &
+                0xAAAA);
+
+        bw.write_be16(result);
+    }
+
+    input += len;
+    return output;
+}
+
+Bytes amigaDeinterleave(const Bytes& input)
+{
+    const uint8_t* ptr = input.cbegin();
+    return amigaDeinterleave(ptr, input.size());
+}

arch/amiga/amiga.h

@@ -1,20 +1,20 @@
 #ifndef AMIGA_H
 #define AMIGA_H
 
+#include "encoders/encoders.h"
+
 #define AMIGA_SECTOR_RECORD 0xaaaa44894489LL
 
-#define AMIGA_RECORD_SIZE 0x21f
+#define AMIGA_TRACKS_PER_DISK 80
+#define AMIGA_SECTORS_PER_TRACK 11
+#define AMIGA_RECORD_SIZE 0x21c
 
-class Sector;
-class Fluxmap;
+extern std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config);
+extern std::unique_ptr<Encoder> createAmigaEncoder(const EncoderProto& config);
 
-class AmigaDecoder : public AbstractDecoder
-{
-public:
-    virtual ~AmigaDecoder() {}
-
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-};
+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

@@ -2,98 +2,83 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
 #include "amiga.h"
 #include "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);
 
-static Bytes deinterleave(const uint8_t*& input, size_t len)
+class AmigaDecoder : public Decoder
 {
-    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++)
+public:
+    AmigaDecoder(const DecoderProto& config):
+        Decoder(config),
+        _config(config.amiga())
     {
-        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;
-}
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(SECTOR_PATTERN);
+    }
 
-static uint32_t checksum(const Bytes& bytes)
+    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)
 {
-    ByteReader br(bytes);
-    uint32_t checksum = 0;
-
-    assert((bytes.size() & 3) == 0);
-    while (!br.eof())
-        checksum ^= br.read_be32();
-
-    return checksum & 0x55555555;
-}
-
-AbstractDecoder::RecordType AmigaDecoder::advanceToNextRecord()
-{
-    _sector->clock = _fmr->seekToPattern(SECTOR_PATTERN);
-    if (_fmr->eof() || !_sector->clock)
-        return UNKNOWN_RECORD;
-    return SECTOR_RECORD;
-}
-
-void AmigaDecoder::decodeSectorRecord()
-{
-    const auto& rawbits = readRawBits(AMIGA_RECORD_SIZE*16);
-    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() + 3;
-
-    Bytes header = deinterleave(ptr, 4);
-    Bytes recoveryinfo = deinterleave(ptr, 16);
-
-    _sector->logicalTrack = header[1] >> 1;
-    _sector->logicalSide = header[1] & 1;
-    _sector->logicalSector = header[2];
-
-    uint32_t wantedheaderchecksum = deinterleave(ptr, 4).reader().read_be32();
-    uint32_t gotheaderchecksum = checksum(rawbytes.slice(6, 40));
-    if (gotheaderchecksum != wantedheaderchecksum)
-        return;
-
-    uint32_t wanteddatachecksum = deinterleave(ptr, 4).reader().read_be32();
-    uint32_t gotdatachecksum = checksum(rawbytes.slice(62, 1024));
-
-    _sector->data.clear();
-    _sector->data.writer().append(deinterleave(ptr, 512)).append(recoveryinfo);
-    _sector->status = (gotdatachecksum == wanteddatachecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    return std::unique_ptr<Decoder>(new AmigaDecoder(config));
 }

arch/amiga/encoder.cc

@@ -0,0 +1,149 @@
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "amiga.h"
+#include "crc.h"
+#include "readerwriter.h"
+#include "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

@@ -1,25 +1,19 @@
 #ifndef APPLE2_H
 #define APPLE2_H
 
-#define APPLE2_SECTOR_RECORD   0xd5aa96
-#define APPLE2_DATA_RECORD     0xd5aaad
+#include <memory.h>
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 
-#define APPLE2_SECTOR_LENGTH   256
+#define APPLE2_SECTOR_RECORD 0xd5aa96
+#define APPLE2_DATA_RECORD 0xd5aaad
+
+#define APPLE2_SECTOR_LENGTH 256
 #define APPLE2_ENCODED_SECTOR_LENGTH 342
 
-class Sector;
-class Fluxmap;
-
-class Apple2Decoder : public AbstractDecoder
-{
-public:
-    virtual ~Apple2Decoder() {}
-
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-    void decodeDataRecord();
-};
+#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

@@ -2,10 +2,11 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
 #include "apple2.h"
+#include "arch/apple2/apple2.pb.h"
+#include "lib/decoders/decoders.pb.h"
 #include "bytes.h"
 #include "fmt/format.h"
 #include <string.h>
@@ -13,22 +14,25 @@
 
 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 });
+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
+#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
+/* 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)
 {
@@ -48,9 +52,11 @@ static Bytes decode_crazy_data(const uint8_t* inp, Sector::Status& status)
         {
             /* 3 * 2 bit */
             output[i + 0] = ((checksum >> 1) & 0x01) | ((checksum << 1) & 0x02);
-            output[i + 86] = ((checksum >> 3) & 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);
+                output[i + 172] =
+                    ((checksum >> 5) & 0x01) | ((checksum >> 3) & 0x02);
         }
     }
 
@@ -60,53 +66,110 @@ static Bytes decode_crazy_data(const uint8_t* inp, Sector::Status& status)
     return output;
 }
 
-uint8_t combine(uint16_t word)
+static uint8_t combine(uint16_t word)
 {
     return word & (word >> 7);
 }
 
-AbstractDecoder::RecordType Apple2Decoder::advanceToNextRecord()
+class Apple2Decoder : public Decoder
 {
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
-	if (matcher == &SECTOR_RECORD_PATTERN)
-		return RecordType::SECTOR_RECORD;
-	if (matcher == &DATA_RECORD_PATTERN)
-		return RecordType::DATA_RECORD;
-	return RecordType::UNKNOWN_RECORD;
-}
+public:
+    Apple2Decoder(const DecoderProto& config): Decoder(config) {}
 
-void Apple2Decoder::decodeSectorRecord()
+    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)
 {
-    /* Skip ID (as we know it's a APPLE2_SECTOR_RECORD). */
-    readRawBits(24);
-
-    /* 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->logicalSector = combine(br.read_be16());
-    uint8_t checksum = combine(br.read_be16());
-    if (checksum == (volume ^ _sector->logicalTrack ^ _sector->logicalSector))
-        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
-}
-
-void Apple2Decoder::decodeDataRecord()
-{
-    /* Check ID. */
-
-    Bytes bytes = toBytes(readRawBits(3*8)).slice(0, 3);
-    if (bytes.reader().read_be24() != APPLE2_DATA_RECORD)
-        return;
-
-    /* Read and decode data. */
-
-    unsigned recordLength = APPLE2_ENCODED_SECTOR_LENGTH + 2;
-    bytes = toBytes(readRawBits(recordLength*8)).slice(0, recordLength);
-
-    _sector->status = Sector::BAD_CHECKSUM;
-    _sector->data = decode_crazy_data(&bytes[0], _sector->status);
+    return std::unique_ptr<Decoder>(new Apple2Decoder(config));
 }

arch/apple2/encoder.cc

@@ -0,0 +1,192 @@
+#include "globals.h"
+#include "arch/apple2/apple2.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "sector.h"
+#include "readerwriter.h"
+#include "image.h"
+#include "fmt/format.h"
+#include "lib/encoders/encoders.pb.h"
+#include <ctype.h>
+#include "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

@@ -3,37 +3,19 @@
 
 /* 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_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_DISK          78
-#define BROTHER_SECTORS_PER_TRACK        12
+#define BROTHER_TRACKS_PER_240KB_DISK 78
+#define BROTHER_TRACKS_PER_120KB_DISK 39
+#define BROTHER_SECTORS_PER_TRACK 12
 
-class Sector;
-class Fluxmap;
-
-class BrotherDecoder : public AbstractDecoder
-{
-public:
-    virtual ~BrotherDecoder() {}
-
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-    void decodeDataRecord();
-};
-
-class BrotherEncoder : public AbstractEncoder
-{
-public:
-	virtual ~BrotherEncoder() {}
-
-public:
-    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
-};
-
-extern FlagGroup brotherEncoderFlags;
+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/brotherdecode.h

@@ -1,28 +0,0 @@
-#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
-
-class Sector;
-class Fluxmap;
-
-class BrotherDecoder : public AbstractDecoder
-{
-public:
-    virtual ~BrotherDecoder() {}
-
-    SectorVector decodeToSectors(const RawRecordVector& rawRecords);
-    int recordMatcher(uint64_t fifo) const;
-};
-
-extern void writeBrotherSectorHeader(std::vector<bool>& bits, unsigned& cursor,
-		int track, int sector);
-extern void writeBrotherSectorData(std::vector<bool>& bits, unsigned& cursor,
-		const std::vector<uint8_t>& data);
-
-#endif

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

@@ -1,10 +1,8 @@
 #include "globals.h"
-#include "sql.h"
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "decoders/decoders.h"
 #include "encoders/encoders.h"
-#include "record.h"
 #include "brother.h"
 #include "sector.h"
 #include "bytes.h"
@@ -13,7 +11,8 @@
 
 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 });
+const FluxMatchers ANY_RECORD_PATTERN(
+    {&SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN});
 
 static std::vector<uint8_t> outputbuffer;
 
@@ -34,76 +33,89 @@ 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
+#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;             
+    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;
+    }
 };
 
-AbstractDecoder::RecordType BrotherDecoder::advanceToNextRecord()
+std::unique_ptr<Decoder> createBrotherDecoder(const DecoderProto& config)
 {
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
-	if (matcher == &SECTOR_RECORD_PATTERN)
-		return RecordType::SECTOR_RECORD;
-	if (matcher == &DATA_RECORD_PATTERN)
-		return RecordType::DATA_RECORD;
-	return RecordType::UNKNOWN_RECORD;
-}
-
-void BrotherDecoder::decodeSectorRecord()
-{
-	readRawBits(32);
-	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 BrotherDecoder::decodeDataRecord()
-{
-	readRawBits(32);
-
-	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;
+    return std::unique_ptr<Decoder>(new BrotherDecoder(config));
 }

arch/brother/encoder.cc

@@ -1,167 +1,154 @@
 #include "globals.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "encoders/encoders.h"
 #include "brother.h"
 #include "crc.h"
-#include "sectorset.h"
-#include "writer.h"
-
-FlagGroup brotherEncoderFlags;
-
-static DoubleFlag clockRateUs(
-	{ "--clock-rate" },
-	"Encoded data clock rate (microseconds).",
-	3.83);
-
-static DoubleFlag postIndexGapMs(
-	{ "--post-index-gap" },
-	"Post-index gap before first sector header (milliseconds).",
-	1.0);
-
-static DoubleFlag sectorSpacingMs(
-	{ "--sector-spacing" },
-	"Time between successive sector headers (milliseconds).",
-	16.2);
-
-static DoubleFlag postHeaderSpacingMs(
-	{ "--post-header-spacing" },
-	"Time between a sector's header and data records (milliseconds).",
-	0.69);
-
-static StringFlag sectorSkew(
-	{ "--sector-skew" },
-	"Order in which to write sectors.",
-	"05a3816b4927");
+#include "readerwriter.h"
+#include "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;             
-};
+    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;
-	}
+    switch (data)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case data:               \
+        return gcr;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
 }
 
-static void write_sector_header(std::vector<bool>& bits, unsigned& cursor,
-		int track, int sector)
+static void write_bits(
+    std::vector<bool>& bits, unsigned& cursor, uint32_t data, int width)
 {
-	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);
+    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_data(std::vector<bool>& bits, unsigned& cursor, const Bytes& data)
+static void write_sector_header(
+    std::vector<bool>& bits, unsigned& cursor, int track, int sector)
 {
-	write_bits(bits, cursor, 0xffffffff, 32);
-	write_bits(bits, cursor, BROTHER_DATA_RECORD, 32);
+    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);
+}
 
-	uint16_t fifo = 0;
-	int width = 0;
+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);
 
-	if (data.size() != BROTHER_DATA_RECORD_PAYLOAD)
-		Error() << "unsupported sector size";
+    uint16_t fifo = 0;
+    int width = 0;
 
-	auto write_byte = [&](uint8_t byte)
-	{
-		fifo |= (byte << (8 - width));
-		width += 8;
+    if (data.size() != BROTHER_DATA_RECORD_PAYLOAD)
+        error("unsupported sector size");
 
-		while (width >= 5)
-		{
-			uint8_t quintet = fifo >> 11;
-			fifo <<= 5;
-			width -= 5;
+    auto write_byte = [&](uint8_t byte)
+    {
+        fifo |= (byte << (8 - width));
+        width += 8;
 
-			write_bits(bits, cursor, encode_data_gcr(quintet), 8);
-		}
-	};
+        while (width >= 5)
+        {
+            uint8_t quintet = fifo >> 11;
+            fifo <<= 5;
+            width -= 5;
 
-	for (uint8_t byte : data)
-		write_byte(byte);
+            write_bits(bits, cursor, encode_data_gcr(quintet), 8);
+        }
+    };
 
-	uint32_t realCrc = crcbrother(data);
-	write_byte(realCrc>>16);
-	write_byte(realCrc>>8);
-	write_byte(realCrc);
-	write_byte(0x58); /* magic */
+    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);
 }
 
-static int charToInt(char c)
+class BrotherEncoder : public Encoder
 {
-	if (isdigit(c))
-		return c - '0';
-	return 10 + tolower(c) - 'a';
-}
+public:
+    BrotherEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.brother())
+    {
+    }
 
-std::unique_ptr<Fluxmap> BrotherEncoder::encode(
-	int physicalTrack, int physicalSide, const SectorSet& allSectors)
+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)
 {
-	if ((physicalTrack < 0) || (physicalTrack >= BROTHER_TRACKS_PER_DISK)
-        || (physicalSide != 0))
-		return std::unique_ptr<Fluxmap>();
-
-	int bitsPerRevolution = 200000.0 / clockRateUs;
-	const std::string& skew = sectorSkew.get();
-	std::vector<bool> bits(bitsPerRevolution);
-	unsigned cursor = 0;
-
-	for (int sectorCount=0; sectorCount<BROTHER_SECTORS_PER_TRACK; sectorCount++)
-	{
-		int sectorId = charToInt(skew.at(sectorCount));
-		double headerMs = postIndexGapMs + sectorCount*sectorSpacingMs;
-		unsigned headerCursor = headerMs*1e3 / clockRateUs;
-		double dataMs = headerMs + postHeaderSpacingMs;
-		unsigned dataCursor = dataMs*1e3 / clockRateUs;
-
-		const auto& sectorData = allSectors.get(physicalTrack, 0, sectorId);
-
-		fillBitmapTo(bits, cursor, headerCursor, { true, false });
-		write_sector_header(bits, cursor, physicalTrack, sectorId);
-		fillBitmapTo(bits, cursor, dataCursor, { true, false });
-		write_sector_data(bits, cursor, sectorData->data);
-	}
-
-	if (cursor > bits.size())
-		Error() << "track data overrun";
-	fillBitmapTo(bits, cursor, bits.size(), { true, false });
-
-	// The pre-index gap is not normally reported.
-	// std::cerr << "pre-index gap " << 200.0 - (double)cursor*clockRateUs/1e3 << std::endl;
-	
-	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
-	fluxmap->appendBits(bits, clockRateUs*1e3);
-	return fluxmap;
+    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.mk

@@ -0,0 +1,43 @@
+LIBARCH_SRCS = \
+	arch/aeslanier/decoder.cc \
+	arch/agat/agat.cc \
+	arch/agat/decoder.cc \
+	arch/agat/encoder.cc \
+	arch/amiga/amiga.cc \
+	arch/amiga/decoder.cc \
+	arch/amiga/encoder.cc \
+	arch/apple2/decoder.cc \
+	arch/apple2/encoder.cc \
+	arch/brother/decoder.cc \
+	arch/brother/encoder.cc \
+	arch/c64/c64.cc \
+	arch/c64/decoder.cc \
+	arch/c64/encoder.cc \
+	arch/f85/decoder.cc \
+	arch/fb100/decoder.cc \
+	arch/ibm/decoder.cc \
+	arch/ibm/encoder.cc \
+	arch/macintosh/decoder.cc \
+	arch/macintosh/encoder.cc \
+	arch/micropolis/decoder.cc \
+	arch/micropolis/encoder.cc \
+	arch/mx/decoder.cc \
+	arch/northstar/decoder.cc \
+	arch/northstar/encoder.cc \
+	arch/rolandd20/decoder.cc \
+	arch/smaky6/decoder.cc \
+	arch/tids990/decoder.cc \
+	arch/tids990/encoder.cc \
+	arch/victor9k/decoder.cc \
+	arch/victor9k/encoder.cc \
+	arch/zilogmcz/decoder.cc \
+
+LIBARCH_OBJS = $(patsubst %.cc, $(OBJDIR)/%.o, $(LIBARCH_SRCS))
+OBJS += $(LIBARCH_OBJS)
+$(LIBARCH_SRCS): | $(PROTO_HDRS)
+$(LIBARCH_SRCS): CFLAGS += $(PROTO_CFLAGS)
+LIBARCH_LIB = $(OBJDIR)/libarch.a
+LIBARCH_LDFLAGS =
+$(LIBARCH_LIB): $(LIBARCH_OBJS)
+
+$(call use-pkgconfig, $(LIBARCH_LIB), $(LIBARCH_OBJS), fmt)

arch/c64/c64.cc

@@ -0,0 +1,28 @@
+#include "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

@@ -1,21 +1,37 @@
 #ifndef C64_H
 #define C64_H
 
-#define C64_SECTOR_RECORD    0xffd49
-#define C64_DATA_RECORD      0xffd57
-#define C64_SECTOR_LENGTH    256
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
 
-class Sector;
-class Fluxmap;
+#define C64_SECTOR_RECORD 0xffd49
+#define C64_DATA_RECORD 0xffd57
+#define C64_SECTOR_LENGTH 256
 
-class Commodore64Decoder : public AbstractDecoder
-{
-public:
-    virtual ~Commodore64Decoder() {}
+/* 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
 
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-    void decodeDataRecord();
-};
+#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

@@ -2,7 +2,6 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
 #include "c64.h"
@@ -14,19 +13,21 @@
 
 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 });
+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
+#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)
 {
@@ -38,11 +39,11 @@ static Bytes decode(const std::vector<bool>& bits)
     while (ii != bits.end())
     {
         uint8_t inputfifo = 0;
-        for (size_t i=0; i<5; i++)
+        for (size_t i = 0; i < 5; i++)
         {
             if (ii == bits.end())
                 break;
-            inputfifo = (inputfifo<<1) | *ii++;
+            inputfifo = (inputfifo << 1) | *ii++;
         }
 
         bitw.push(decode_data_gcr(inputfifo), 4);
@@ -52,41 +53,50 @@ static Bytes decode(const std::vector<bool>& bits)
     return output;
 }
 
-AbstractDecoder::RecordType Commodore64Decoder::advanceToNextRecord()
+class Commodore64Decoder : public Decoder
 {
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
-	if (matcher == &SECTOR_RECORD_PATTERN)
-		return RecordType::SECTOR_RECORD;
-	if (matcher == &DATA_RECORD_PATTERN)
-		return RecordType::DATA_RECORD;
-	return RecordType::UNKNOWN_RECORD;
-}
+public:
+    Commodore64Decoder(const DecoderProto& config): Decoder(config) {}
 
-void Commodore64Decoder::decodeSectorRecord()
+    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)
 {
-    readRawBits(20);
-
-    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 Commodore64Decoder::decodeDataRecord()
-{
-    readRawBits(20);
-
-    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;
+    return std::unique_ptr<Decoder>(new Commodore64Decoder(config));
 }

arch/c64/encoder.cc

@@ -0,0 +1,338 @@
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "c64.h"
+#include "crc.h"
+#include "sector.h"
+#include "readerwriter.h"
+#include "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 "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;
+    }
+}
+
+void bindump(std::ostream& stream, std::vector<bool>& buffer)
+{
+    size_t pos = 0;
+
+    while ((pos < buffer.size()) and (pos < 520))
+    {
+        stream << fmt::format("{:5d} : ", pos);
+        for (int i = 0; i < 40; i++)
+        {
+            if ((pos + i) < buffer.size())
+                stream << fmt::format("{:01b}", (buffer[pos + i]));
+            else
+                stream << "-- ";
+            if ((((pos + i + 1) % 8) == 0) and i != 0)
+                stream << "  ";
+        }
+        stream << std::endl;
+        pos += 40;
+    }
+}
+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

@@ -2,7 +2,6 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
 #include "f85.h"
@@ -14,19 +13,21 @@
 
 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 });
+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
+#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)
 {
@@ -38,11 +39,11 @@ static Bytes decode(const std::vector<bool>& bits)
     while (ii != bits.end())
     {
         uint8_t inputfifo = 0;
-        for (size_t i=0; i<5; i++)
+        for (size_t i = 0; i < 5; i++)
         {
             if (ii == bits.end())
                 break;
-            inputfifo = (inputfifo<<1) | *ii++;
+            inputfifo = (inputfifo << 1) | *ii++;
         }
 
         bitw.push(decode_data_gcr(inputfifo), 4);
@@ -52,49 +53,58 @@ static Bytes decode(const std::vector<bool>& bits)
     return output;
 }
 
-AbstractDecoder::RecordType DurangoF85Decoder::advanceToNextRecord()
+class DurangoF85Decoder : public Decoder
 {
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
-	if (matcher == &SECTOR_RECORD_PATTERN)
-		return RecordType::SECTOR_RECORD;
-	if (matcher == &DATA_RECORD_PATTERN)
-		return RecordType::DATA_RECORD;
-	return RecordType::UNKNOWN_RECORD;
-}
+public:
+    DurangoF85Decoder(const DecoderProto& config): Decoder(config) {}
 
-void DurangoF85Decoder::decodeSectorRecord()
+    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)
 {
-    /* Skip sync bits and ID byte. */
-
-    readRawBits(24);
-
-    /* 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 DurangoF85Decoder::decodeDataRecord()
-{
-    /* Skip sync bits ID byte. */
-
-    readRawBits(24);
-
-    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;
+    return std::unique_ptr<Decoder>(new DurangoF85Decoder(config));
 }

arch/f85/f85.h

@@ -2,20 +2,10 @@
 #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
+#define F85_DATA_RECORD 0xffffcb   /* 1111 1111 1111 1111 1100 1101 */
+#define F85_SECTOR_LENGTH 512
 
-class Sector;
-class Fluxmap;
-
-class DurangoF85Decoder : public AbstractDecoder
-{
-public:
-    virtual ~DurangoF85Decoder() {}
-
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-    void decodeDataRecord();
-};
+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

@@ -2,24 +2,22 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
 #include "fb100.h"
 #include "crc.h"
 #include "bytes.h"
 #include "decoders/rawbits.h"
-#include "track.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
@@ -99,37 +97,46 @@ static uint16_t checksum(const Bytes& bytes)
     return (crchi << 8) | crclo;
 }
 
-AbstractDecoder::RecordType Fb100Decoder::advanceToNextRecord()
+class Fb100Decoder : public Decoder
 {
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(SECTOR_ID_PATTERN, matcher);
-    if (matcher == &SECTOR_ID_PATTERN)
-		return RecordType::SECTOR_RECORD;
-	return RecordType::UNKNOWN_RECORD;
+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));
 }
-
-void Fb100Decoder::decodeSectorRecord()
-{
-    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;
-}

arch/fb100/fb100.h

@@ -5,18 +5,6 @@
 #define FB100_ID_SIZE 17
 #define FB100_PAYLOAD_SIZE 0x500
 
-class Sector;
-class Fluxmap;
-class Track;
-
-class Fb100Decoder : public AbstractDecoder
-{
-public:
-    virtual ~Fb100Decoder() {}
-
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-};
+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

@@ -5,25 +5,27 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "sector.h"
-#include "record.h"
+#include "arch/ibm/ibm.pb.h"
+#include "proto.h"
+#include "lib/layout.h"
 #include <string.h>
 
 static_assert(std::is_trivially_copyable<IbmIdam>::value,
-		"IbmIdam is not trivially copyable");
+    "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
@@ -31,7 +33,7 @@ static_assert(std::is_trivially_copyable<IbmIdam>::value,
  */
 const FluxPattern FM_IDAM_PATTERN(16, 0xf57e);
 
-/* 
+/*
  * DAM1 record:
  * flux:   XXXX-X-X-XX-X-X- = 0xf56a
  * clock:  X X - - - X X X  = 0xc7
@@ -39,7 +41,7 @@ const FluxPattern FM_IDAM_PATTERN(16, 0xf57e);
  */
 const FluxPattern FM_DAM1_PATTERN(16, 0xf56a);
 
-/* 
+/*
  * DAM2 record:
  * flux:   XXXX-X-X-XX-XXXX = 0xf56f
  * clock:  X X - - - X X X  = 0xc7
@@ -47,7 +49,7 @@ const FluxPattern FM_DAM1_PATTERN(16, 0xf56a);
  */
 const FluxPattern FM_DAM2_PATTERN(16, 0xf56f);
 
-/* 
+/*
  * TRS80DAM1 record:
  * flux:   XXXX-X-X-XX-X-XX = 0xf56b
  * clock:  X X - - - X X X  = 0xc7
@@ -55,13 +57,13 @@ const FluxPattern FM_DAM2_PATTERN(16, 0xf56f);
  */
 const FluxPattern FM_TRS80DAM1_PATTERN(16, 0xf56b);
 
-/* 
+/*
  * TRS80DAM2 record:
- * flux:   XXXX-X-X-XX-XXX- = 0xf56c
+ * 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, 0xf56c);
+const FluxPattern FM_TRS80DAM2_PATTERN(16, 0xf56e);
 
 /* MFM record separator:
  * 0xA1 is:
@@ -71,83 +73,178 @@ const FluxPattern FM_TRS80DAM2_PATTERN(16, 0xf56c);
  *                       ^^^^^
  * 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(16, 0x4489);
+const FluxPattern MFM_PATTERN(48, 0x448944894489LL);
 
-const FluxMatchers ANY_RECORD_PATTERN(
+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())
     {
-        &MFM_PATTERN,
-        &FM_IDAM_PATTERN,
-        &FM_DAM1_PATTERN,
-        &FM_DAM2_PATTERN,
-        &FM_TRS80DAM1_PATTERN,
-        &FM_TRS80DAM2_PATTERN,
     }
-);
 
-AbstractDecoder::RecordType IbmDecoder::advanceToNextRecord()
-{
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
-
-    /* If this is the MFM prefix byte, the the decoder is going to expect three
-     * extra bytes on the front of the header. */
-    _currentHeaderLength = (matcher == &MFM_PATTERN) ? 3 : 0;
-
-    Fluxmap::Position here = tell();
-    if (_currentHeaderLength > 0)
-        readRawBits(_currentHeaderLength*16);
-    auto idbits = readRawBits(16);
-    uint8_t id = decodeFmMfm(idbits).slice(0, 1)[0];
-    seek(here);
-    
-    switch (id)
+    nanoseconds_t advanceToNextRecord() override
     {
-        case IBM_IDAM:
-            return RecordType::SECTOR_RECORD;
-
-        case IBM_DAM1:
-        case IBM_DAM2:
-        case IBM_TRS80DAM1:
-        case IBM_TRS80DAM2:
-            return RecordType::DATA_RECORD;
+        return seekToPattern(ANY_RECORD_PATTERN);
     }
-    return RecordType::UNKNOWN_RECORD;
-}
 
-void IbmDecoder::decodeSectorRecord()
+    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)
 {
-    unsigned recordSize = _currentHeaderLength + IBM_IDAM_LEN;
-    auto bits = readRawBits(recordSize*16);
-    auto bytes = decodeFmMfm(bits).slice(0, recordSize);
-
-    ByteReader br(bytes);
-    br.seek(_currentHeaderLength);
-    br.read_8(); /* skip ID byte */
-    _sector->logicalTrack = br.read_8();
-    _sector->logicalSide = br.read_8();
-    _sector->logicalSector = br.read_8() - _sectorBase;
-    _currentSectorSize = 1 << (br.read_8() + 7);
-    uint16_t wantCrc = br.read_be16();
-    uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, _currentHeaderLength + 5));
-    if (wantCrc == gotCrc)
-        _sector->status = Sector::DATA_MISSING; /* correct but unintuitive */
-}
-
-void IbmDecoder::decodeDataRecord()
-{
-    unsigned recordLength = _currentHeaderLength + _currentSectorSize + 3;
-    auto bits = readRawBits(recordLength*16);
-    auto bytes = decodeFmMfm(bits).slice(0, recordLength);
-
-    ByteReader br(bytes);
-    br.seek(_currentHeaderLength);
-    br.read_8(); /* skip ID byte */
-
-    _sector->data = br.read(_currentSectorSize);
-    uint16_t wantCrc = br.read_be16();
-    uint16_t gotCrc = crc16(CCITT_POLY, bytes.slice(0, recordLength-2));
-    _sector->status = (wantCrc == gotCrc) ? Sector::OK : Sector::BAD_CHECKSUM;
+    return std::unique_ptr<Decoder>(new IbmDecoder(config));
 }

arch/ibm/encoder.cc

@@ -0,0 +1,282 @@
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "ibm.h"
+#include "crc.h"
+#include "readerwriter.h"
+#include "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

@@ -1,96 +1,37 @@
 #ifndef IBM_H
 #define IBM_H
 
-#include "decoders/decoders.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 */
+#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 cylinder;
+    uint8_t track;
     uint8_t side;
     uint8_t sector;
     uint8_t sectorSize;
     uint8_t crc[2];
 };
 
-class IbmDecoder : public AbstractDecoder
-{
-public:
-    IbmDecoder(unsigned sectorBase):
-        _sectorBase(sectorBase)
-    {}
+class Encoder;
+class Decoder;
+class DecoderProto;
+class EncoderProto;
 
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-    void decodeDataRecord();
-
-private:
-    unsigned _sectorBase;
-    unsigned _currentSectorSize;
-    unsigned _currentHeaderLength;
-};
-
-#if 0
-class AbstractIbmDecoder : public AbstractSoftSectorDecoder
-{
-public:
-    AbstractIbmDecoder(unsigned sectorIdBase):
-        _sectorIdBase(sectorIdBase)
-    {}
-    virtual ~AbstractIbmDecoder() {}
-
-    SectorVector decodeToSectors(const RawRecordVector& rawRecords, unsigned physicalTrack, unsigned physicalSide);
-
-protected:
-    virtual int skipHeaderBytes() const = 0;
-
-private:
-    unsigned _sectorIdBase;
-};
-
-class IbmFmDecoder : public AbstractIbmDecoder
-{
-public:
-    IbmFmDecoder(unsigned sectorIdBase):
-        AbstractIbmDecoder(sectorIdBase)
-    {}
-
-    int recordMatcher(uint64_t fifo) const;
-
-protected:
-    int skipHeaderBytes() const
-    { return 0; }
-};
-
-class IbmMfmDecoder : public AbstractIbmDecoder
-{
-public:
-    IbmMfmDecoder(unsigned sectorIdBase):
-        AbstractIbmDecoder(sectorIdBase)
-    {}
-
-    nanoseconds_t guessClock(Fluxmap& fluxmap) const;
-    int recordMatcher(uint64_t fifo) const;
-
-protected:
-    int skipHeaderBytes() const
-    { return 3; }
-};
-#endif
+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

@@ -2,10 +2,8 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
-#include "track.h"
 #include "macintosh.h"
 #include "bytes.h"
 #include "fmt/format.h"
@@ -14,22 +12,25 @@
 
 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 });
+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
+#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
+/* 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)
 {
@@ -43,7 +44,7 @@ static Bytes decode_crazy_data(const Bytes& input, Sector::Status& status)
     uint8_t b2[LOOKUP_LEN + 1];
     uint8_t b3[LOOKUP_LEN + 1];
 
-    for (int i=0; i<=LOOKUP_LEN; i++)
+    for (int i = 0; i <= LOOKUP_LEN; i++)
     {
         uint8_t w4 = br.read_8();
         uint8_t w1 = br.read_8();
@@ -118,69 +119,77 @@ static Bytes decode_crazy_data(const Bytes& input, Sector::Status& status)
 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 6).
+     * bit 5) and also whether we're above track 0x3f (in bit 0).
      */
 
-    return !!(side & 0x40);
+    return !!(side & 0x20);
 }
 
-AbstractDecoder::RecordType MacintoshDecoder::advanceToNextRecord()
+class MacintoshDecoder : public Decoder
 {
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
-	if (matcher == &SECTOR_RECORD_PATTERN)
-		return SECTOR_RECORD;
-	if (matcher == &DATA_RECORD_PATTERN)
-		return DATA_RECORD;
-	return UNKNOWN_RECORD;
-}
+public:
+    MacintoshDecoder(const DecoderProto& config): Decoder(config) {}
 
-void MacintoshDecoder::decodeSectorRecord()
+    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)
 {
-    /* Skip ID (as we know it's a MAC_SECTOR_RECORD). */
-    readRawBits(24);
-
-    /* Read header. */
-
-    auto header = toBytes(readRawBits(7*8)).slice(0, 7);
-                
-    uint8_t encodedTrack = decode_data_gcr(header[0]);
-    if (encodedTrack != (_track->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 = _track->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 MacintoshDecoder::decodeDataRecord()
-{
-    auto id = toBytes(readRawBits(24)).reader().read_be24();
-    if (id != 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));
+    return std::unique_ptr<Decoder>(new MacintoshDecoder(config));
 }

arch/macintosh/encoder.cc

@@ -0,0 +1,258 @@
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "macintosh.h"
+#include "crc.h"
+#include "readerwriter.h"
+#include "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

@@ -1,24 +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_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_SECTOR_LENGTH 524 /* yes, really */
 #define MAC_ENCODED_SECTOR_LENGTH 703
+#define MAC_FORMAT_BYTE 0x22
 
-class Sector;
-class Fluxmap;
+#define MAC_TRACKS_PER_DISK 80
 
-class MacintoshDecoder : public AbstractDecoder
-{
-public:
-    virtual ~MacintoshDecoder() {}
+class Encoder;
+class Decoder;
+class DecoderProto;
+class EncoderProto;
 
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-    void decodeDataRecord();
-};
+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,207 @@
+#include "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "sector.h"
+#include "micropolis.h"
+#include "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;
+}
+
+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.
+         */
+        if (now > (getFluxmapDuration() - 12.5e6))
+        {
+            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.
+         */
+        if (_sector->headerStartTime > (getFluxmapDuration() - 12.5e6))
+        {
+            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);
+        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");
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : 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,111 @@
+#include "globals.h"
+#include "micropolis.h"
+#include "sector.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "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)
+{
+    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)));
+        for (int i = 0; i < 5; i++)
+            writer.write_8(0); /* 4 byte ECC and ECC not present flag */
+    }
+    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);
+        unsigned cursor = 0;
+
+        for (const auto& sectorData : sectors)
+            write_sector(bits, cursor, sectorData);
+
+        if (cursor != bits.size())
+            error("track data mismatched length");
+
+        std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+        fluxmap->appendBits(bits,
+            calculatePhysicalClockPeriod(_config.clock_period_us() * 1e3,
+                _config.rotational_period_ms() * 1e6));
+        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,21 @@
+#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);
+
+#endif

arch/micropolis/micropolis.proto

@@ -0,0 +1,24 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message MicropolisDecoderProto {
+	enum ChecksumType {
+		AUTO = 0;
+		MICROPOLIS = 1;
+		MZOS = 2;
+	}
+
+	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"];
+}
+
+message MicropolisEncoderProto {
+    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" ];
+}
+

arch/mx/decoder.cc

@@ -5,8 +5,6 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "sector.h"
-#include "record.h"
-#include "track.h"
 #include <string.h>
 
 const int SECTOR_SIZE = 256;
@@ -18,58 +16,68 @@ const int SECTOR_SIZE = 256;
  */
 
 /* 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
+ *    a    a    a    a    f    f    a    f encoded nibbles
  */
 const FluxPattern ID_PATTERN(32, 0xaaaaffaf);
 
-void MxDecoder::beginTrack()
+class MxDecoder : public Decoder
 {
-    _currentSector = -1;
-    _clock = 0;
-}
+public:
+    MxDecoder(const DecoderProto& config): Decoder(config) {}
 
-AbstractDecoder::RecordType MxDecoder::advanceToNextRecord()
-{
-    if (_currentSector == -1)
+    void beginTrack() override
     {
-        /* First sector in the track: look for the sync marker. */
-        const FluxMatcher* matcher = nullptr;
-        _sector->clock = _clock = _fmr->seekToPattern(ID_PATTERN, matcher);
-        readRawBits(32); /* skip the ID mark */
-        _logicalTrack = decodeFmMfm(readRawBits(32)).reader().read_be16();
-    }
-    else if (_currentSector == 10)
-    {
-        /* That was the last sector on the disk. */
-        return UNKNOWN_RECORD;
-    }
-    else
-    {
-        /* Otherwise we assume the clock from the first sector is still valid.
-         * The decoder framwork will automatically stop when we hit the end of
-         * the track. */
-        _sector->clock = _clock;
+        _clock = _sector->clock = seekToPattern(ID_PATTERN);
+        _currentSector = 0;
     }
 
-    _currentSector++;
-    return SECTOR_RECORD;
-}
+    nanoseconds_t advanceToNextRecord() override
+    {
+        if (_currentSector == 11)
+        {
+            /* That was the last sector on the disk. */
+            return 0;
+        }
+        else
+            return _clock;
+    }
 
-void MxDecoder::decodeSectorRecord()
+    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)
 {
-    auto bits = readRawBits((SECTOR_SIZE+2)*16);
-    auto bytes = decodeFmMfm(bits).slice(0, SECTOR_SIZE+2).swab();
-
-    uint16_t gotChecksum = 0;
-    ByteReader br(bytes);
-    for (int i=0; i<(SECTOR_SIZE/2); i++)
-        gotChecksum += br.read_le16();
-    uint16_t wantChecksum = br.read_le16();
-
-    _sector->logicalTrack = _logicalTrack;
-    _sector->logicalSide = _track->physicalSide;
-    _sector->logicalSector = _currentSector;
-    _sector->data = bytes.slice(0, SECTOR_SIZE);
-    _sector->status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    return std::unique_ptr<Decoder>(new MxDecoder(config));
 }

arch/mx/mx.h

@@ -3,19 +3,6 @@
 
 #include "decoders/decoders.h"
 
-class MxDecoder : public AbstractDecoder
-{
-public:
-    virtual ~MxDecoder() {}
-
-    void beginTrack();
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-
-private:
-    nanoseconds_t _clock;
-    int _currentSector;
-    int _logicalTrack;
-};
+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 "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "decoders/decoders.h"
+#include "sector.h"
+#include "northstar.h"
+#include "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 "globals.h"
+#include "northstar.h"
+#include "sector.h"
+#include "bytes.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "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 "globals.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "protocol.h"
+#include "decoders/decoders.h"
+#include "sector.h"
+#include "smaky6.h"
+#include "bytes.h"
+#include "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,6 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message Smaky6DecoderProto {}
+

arch/tids990/decoder.cc

@@ -0,0 +1,100 @@
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "tids990/tids990.h"
+#include "crc.h"
+#include "fluxmap.h"
+#include "decoders/fluxmapreader.h"
+#include "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 "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "tids990.h"
+#include "crc.h"
+#include "readerwriter.h"
+#include "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

arch/tids990/tids990.proto

@@ -0,0 +1,25 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message Tids990DecoderProto {}
+
+message Tids990EncoderProto {
+	optional double rotational_period_ms = 1 [ default = 166,
+		(help) = "length of a track" ];
+	optional int32 sector_count = 2 [ default = 26,
+		(help) = "number of sectors per track" ];
+	optional double clock_period_us = 3 [ default = 2,
+		(help) = "clock rate of data to write" ];
+	optional int32 am1_byte = 4 [ default = 0x2244,
+		(help) = "16-bit RAW bit pattern to use for the AM1 ID byte" ];
+	optional int32 am2_byte = 5 [ default = 0x2245,
+		(help) = "16-bit RAW bit pattern to use for the AM2 ID byte" ];
+	optional int32 gap1_bytes = 6 [ default = 80,
+		(help) = "size of gap 1 (the post-index gap)" ];
+	optional int32 gap2_bytes = 7 [ default = 21,
+		(help) = "size of gap 2 (the post-ID gap)" ];
+	optional int32 gap3_bytes = 8 [ default = 51,
+		(help) = "size of gap 3 (the post-data or format gap)" ];
+}
+

arch/victor9k/decoder.cc

@@ -2,32 +2,32 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
 #include "victor9k.h"
 #include "crc.h"
 #include "bytes.h"
-#include "track.h"
 #include "fmt/format.h"
 #include <string.h>
 #include <algorithm>
 
 const FluxPattern SECTOR_RECORD_PATTERN(32, VICTOR9K_SECTOR_RECORD);
 const FluxPattern DATA_RECORD_PATTERN(32, VICTOR9K_DATA_RECORD);
-const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });
+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
+#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)
 {
@@ -39,11 +39,11 @@ static Bytes decode(const std::vector<bool>& bits)
     while (ii != bits.end())
     {
         uint8_t inputfifo = 0;
-        for (size_t i=0; i<5; i++)
+        for (size_t i = 0; i < 5; i++)
         {
             if (ii == bits.end())
                 break;
-            inputfifo = (inputfifo<<1) | *ii++;
+            inputfifo = (inputfifo << 1) | *ii++;
         }
 
         uint8_t decoded = decode_data_gcr(inputfifo);
@@ -54,58 +54,65 @@ static Bytes decode(const std::vector<bool>& bits)
     return output;
 }
 
-AbstractDecoder::RecordType Victor9kDecoder::advanceToNextRecord()
+class Victor9kDecoder : public Decoder
 {
-	const FluxMatcher* matcher = nullptr;
-	_sector->clock = _fmr->seekToPattern(ANY_RECORD_PATTERN, matcher);
-	if (matcher == &SECTOR_RECORD_PATTERN)
-		return SECTOR_RECORD;
-	if (matcher == &DATA_RECORD_PATTERN)
-		return DATA_RECORD;
-	return UNKNOWN_RECORD;
-}
+public:
+    Victor9kDecoder(const DecoderProto& config): Decoder(config) {}
 
-void Victor9kDecoder::decodeSectorRecord()
+    nanoseconds_t advanceToNextRecord() override
+    {
+        return seekToPattern(ANY_RECORD_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        /* Check the ID. */
+
+        if (readRaw32() != VICTOR9K_SECTOR_RECORD)
+            return;
+
+        /* Read header. */
+
+        auto bytes = decode(readRawBits(3 * 10)).slice(0, 3);
+
+        uint8_t rawTrack = bytes[0];
+        _sector->logicalSector = bytes[1];
+        uint8_t gotChecksum = bytes[2];
+
+        _sector->logicalTrack = rawTrack & 0x7f;
+        _sector->logicalSide = rawTrack >> 7;
+        uint8_t wantChecksum = bytes[0] + bytes[1];
+        if ((_sector->logicalSector > 20) || (_sector->logicalTrack > 85) ||
+            (_sector->logicalSide > 1))
+            return;
+
+        if (wantChecksum == gotChecksum)
+            _sector->status =
+                Sector::DATA_MISSING; /* unintuitive but correct */
+    }
+
+    void decodeDataRecord() override
+    {
+        /* Check the ID. */
+
+        if (readRaw32() != VICTOR9K_DATA_RECORD)
+            return;
+
+        /* Read data. */
+
+        auto bytes = decode(readRawBits((VICTOR9K_SECTOR_LENGTH + 4) * 10))
+                         .slice(0, VICTOR9K_SECTOR_LENGTH + 4);
+        ByteReader br(bytes);
+
+        _sector->data = br.read(VICTOR9K_SECTOR_LENGTH);
+        uint16_t gotChecksum = sumBytes(_sector->data);
+        uint16_t wantChecksum = br.read_le16();
+        _sector->status =
+            (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createVictor9kDecoder(const DecoderProto& config)
 {
-    /* Skip the sync marker bit. */
-    readRawBits(23);
-
-    /* Read header. */
-
-    auto bytes = decode(readRawBits(4*10)).slice(0, 4);
-
-    uint8_t rawTrack = bytes[1];
-    _sector->logicalSector = bytes[2];
-    uint8_t gotChecksum = bytes[3];
-
-    _sector->logicalTrack = rawTrack & 0x7f;
-    _sector->logicalSide = rawTrack >> 7;
-    uint8_t wantChecksum = bytes[1] + bytes[2];
-    if ((_sector->logicalSector > 20) || (_sector->logicalTrack > 85) || (_sector->logicalSide > 1))
-        return;
-                
-    if (wantChecksum == gotChecksum)
-        _sector->status = Sector::DATA_MISSING; /* unintuitive but correct */
-}
-
-void Victor9kDecoder::decodeDataRecord()
-{
-    /* Skip the sync marker bit. */
-    readRawBits(23);
-
-    /* Read data. */
-
-    auto bytes = decode(readRawBits((VICTOR9K_SECTOR_LENGTH+5)*10))
-        .slice(0, VICTOR9K_SECTOR_LENGTH+5);
-    ByteReader br(bytes);
-
-    /* Check that this is actually a data record. */
-    
-    if (br.read_8() != 8)
-        return;
-
-    _sector->data = br.read(VICTOR9K_SECTOR_LENGTH);
-    uint16_t gotChecksum = sumBytes(_sector->data);
-    uint16_t wantChecksum = br.read_le16();
-    _sector->status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    return std::unique_ptr<Decoder>(new Victor9kDecoder(config));
 }

arch/victor9k/encoder.cc

@@ -0,0 +1,210 @@
+#include "globals.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "victor9k.h"
+#include "crc.h"
+#include "sector.h"
+#include "readerwriter.h"
+#include "image.h"
+#include "fmt/format.h"
+#include "arch/victor9k/victor9k.pb.h"
+#include "lib/encoders/encoders.pb.h"
+#include "lib/layout.h"
+#include <ctype.h>
+#include "bytes.h"
+
+static bool lastBit;
+
+static void write_zero_bits(
+    std::vector<bool>& bits, unsigned& cursor, unsigned count)
+{
+    while (count--)
+    {
+        if (cursor < bits.size())
+            lastBit = bits[cursor++] = 0;
+    }
+}
+
+static void write_one_bits(
+    std::vector<bool>& bits, unsigned& cursor, unsigned count)
+{
+    while (count--)
+    {
+        if (cursor < bits.size())
+            lastBit = bits[cursor++] = 1;
+    }
+}
+
+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 int encode_data_gcr(uint8_t data)
+{
+    switch (data & 0x0f)
+    {
+#define GCR_ENTRY(gcr, data) \
+    case data:               \
+        return gcr;
+#include "data_gcr.h"
+#undef GCR_ENTRY
+    }
+    return -1;
+}
+
+static void write_byte(std::vector<bool>& bits, unsigned& cursor, uint8_t b)
+{
+    write_bits(bits, cursor, encode_data_gcr(b >> 4), 5);
+    write_bits(bits, cursor, encode_data_gcr(b), 5);
+}
+
+static void write_bytes(
+    std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
+{
+    for (uint8_t b : bytes)
+        write_byte(bits, cursor, b);
+}
+
+static void write_gap(std::vector<bool>& bits, unsigned& cursor, int length)
+{
+    for (int i = 0; i < length / 10; i++)
+        write_byte(bits, cursor, '0');
+}
+
+static void write_sector(std::vector<bool>& bits,
+    unsigned& cursor,
+    const Victor9kEncoderProto::TrackdataProto& trackdata,
+    const Sector& sector)
+{
+    write_one_bits(bits, cursor, trackdata.pre_header_sync_bits());
+    write_bits(bits, cursor, VICTOR9K_SECTOR_RECORD, 10);
+
+    uint8_t encodedTrack = sector.logicalTrack | (sector.logicalSide << 7);
+    uint8_t encodedSector = sector.logicalSector;
+    write_bytes(bits,
+        cursor,
+        Bytes{
+            encodedTrack,
+            encodedSector,
+            (uint8_t)(encodedTrack + encodedSector),
+        });
+
+    write_gap(bits, cursor, trackdata.post_header_gap_bits());
+
+    write_one_bits(bits, cursor, trackdata.pre_data_sync_bits());
+    write_bits(bits, cursor, VICTOR9K_DATA_RECORD, 10);
+
+    write_bytes(bits, cursor, sector.data);
+
+    Bytes checksum(2);
+    checksum.writer().write_le16(sumBytes(sector.data));
+    write_bytes(bits, cursor, checksum);
+    write_gap(bits, cursor, trackdata.post_data_gap_bits());
+}
+
+class Victor9kEncoder : public Encoder
+{
+public:
+    Victor9kEncoder(const EncoderProto& config):
+        Encoder(config),
+        _config(config.victor9k())
+    {
+    }
+
+private:
+    void getTrackFormat(Victor9kEncoderProto::TrackdataProto& trackdata,
+        unsigned track,
+        unsigned head)
+    {
+        trackdata.Clear();
+        for (const auto& f : _config.trackdata())
+        {
+            if (f.has_min_track() && (track < f.min_track()))
+                continue;
+            if (f.has_max_track() && (track > f.max_track()))
+                continue;
+            if (f.has_head() && (head != f.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
+    {
+        Victor9kEncoderProto::TrackdataProto trackdata;
+        getTrackFormat(
+            trackdata, trackInfo->logicalTrack, trackInfo->logicalSide);
+
+        unsigned bitsPerRevolution = (trackdata.rotational_period_ms() * 1e3) /
+                                     trackdata.clock_period_us();
+        std::vector<bool> bits(bitsPerRevolution);
+        nanoseconds_t clockPeriod =
+            calculatePhysicalClockPeriod(trackdata.clock_period_us() * 1e3,
+                trackdata.rotational_period_ms() * 1e6);
+        unsigned cursor = 0;
+
+        fillBitmapTo(bits,
+            cursor,
+            trackdata.post_index_gap_us() * 1e3 / clockPeriod,
+            {true, false});
+        lastBit = false;
+
+        for (const auto& sector : sectors)
+            write_sector(bits, cursor, trackdata, *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, clockPeriod);
+        return fluxmap;
+    }
+
+private:
+    const Victor9kEncoderProto& _config;
+};
+
+std::unique_ptr<Encoder> createVictor9kEncoder(const EncoderProto& config)
+{
+    return std::unique_ptr<Encoder>(new Victor9kEncoder(config));
+}
+
+// vim: sw=4 ts=4 et

arch/victor9k/victor9k.h

@@ -1,22 +1,26 @@
 #ifndef VICTOR9K_H
 #define VICTOR9K_H
 
-#define VICTOR9K_SECTOR_RECORD 0xfffffeab
-#define VICTOR9K_DATA_RECORD   0xfffffea4
+class Encoder;
+class Decoder;
+class EncoderProto;
+class DecoderProto;
+
+/* ... 1101 0101 0111
+ *       ^^ ^^^^ ^^^^ ten bit IO byte */
+#define VICTOR9K_SECTOR_RECORD 0xfffffd57
+#define VICTOR9K_HEADER_ID 0x7
+
+/* ... 1101 0100 1001
+ *       ^^ ^^^^ ^^^^ ten bit IO byte */
+#define VICTOR9K_DATA_RECORD 0xfffffd49
+#define VICTOR9K_DATA_ID 0x8
 
 #define VICTOR9K_SECTOR_LENGTH 512
 
-class Sector;
-class Fluxmap;
-
-class Victor9kDecoder : public AbstractDecoder
-{
-public:
-    virtual ~Victor9kDecoder() {}
-
-    RecordType advanceToNextRecord();
-    void decodeSectorRecord();
-    void decodeDataRecord();
-};
+extern std::unique_ptr<Decoder> createVictor9kDecoder(
+    const DecoderProto& config);
+extern std::unique_ptr<Encoder> createVictor9kEncoder(
+    const EncoderProto& config);
 
 #endif

arch/victor9k/victor9k.proto

@@ -0,0 +1,36 @@
+syntax = "proto2";
+
+import "lib/common.proto";
+
+message Victor9kDecoderProto {}
+
+// NEXT: 12
+message Victor9kEncoderProto
+{
+    message TrackdataProto
+    {
+        optional int32 min_track = 1
+            [ (help) = "minimum track this format applies to" ];
+        optional int32 max_track = 2
+            [ (help) = "maximum track this format applies to" ];
+        optional int32 head = 3
+            [ (help) = "which head this format applies to" ];
+
+        optional double rotational_period_ms = 4
+            [ (help) = "original rotational period of this track" ];
+        optional double clock_period_us = 5
+            [ (help) = "original data rate of this track" ];
+        optional double post_index_gap_us = 6
+            [ (help) = "size of post-index gap" ];
+        optional int32 pre_header_sync_bits = 10
+            [ (help) = "number of sync bits before the sector header" ];
+        optional int32 pre_data_sync_bits = 8
+            [ (help) = "number of sync bits before the sector data" ];
+        optional int32 post_data_gap_bits = 9
+            [ (help) = "size of gap between data and the next header" ];
+        optional int32 post_header_gap_bits = 11
+            [ (help) = "size of gap between header and the data" ];
+    }
+
+    repeated TrackdataProto trackdata = 1;
+}

arch/zilogmcz/decoder.cc

@@ -2,7 +2,6 @@
 #include "fluxmap.h"
 #include "decoders/fluxmapreader.h"
 #include "protocol.h"
-#include "record.h"
 #include "decoders/decoders.h"
 #include "sector.h"
 #include "zilogmcz.h"
@@ -14,35 +13,43 @@
 
 static const FluxPattern SECTOR_START_PATTERN(16, 0xaaab);
 
-AbstractDecoder::RecordType ZilogMczDecoder::advanceToNextRecord()
+class ZilogMczDecoder : public Decoder
 {
-	const FluxMatcher* matcher = nullptr;
-    _fmr->seekToIndexMark();
-	_sector->clock = _fmr->seekToPattern(SECTOR_START_PATTERN, matcher);
-	if (matcher == &SECTOR_START_PATTERN)
-		return SECTOR_RECORD;
-	return UNKNOWN_RECORD;
-}
+public:
+    ZilogMczDecoder(const DecoderProto& config): Decoder(config) {}
 
-void ZilogMczDecoder::decodeSectorRecord()
+    nanoseconds_t advanceToNextRecord() override
+    {
+        seekToIndexMark();
+        return seekToPattern(SECTOR_START_PATTERN);
+    }
+
+    void decodeSectorRecord() override
+    {
+        readRawBits(14);
+
+        auto rawbits = readRawBits(140 * 16);
+        auto bytes = decodeFmMfm(rawbits).slice(0, 140);
+        ByteReader br(bytes);
+
+        _sector->logicalSector = br.read_8() & 0x1f;
+        _sector->logicalSide = 0;
+        _sector->logicalTrack = br.read_8() & 0x7f;
+        if (_sector->logicalSector > 31)
+            return;
+        if (_sector->logicalTrack > 80)
+            return;
+
+        _sector->data = br.read(132);
+        uint16_t wantChecksum = br.read_be16();
+        uint16_t gotChecksum = crc16(MODBUS_POLY, 0x0000, bytes.slice(0, 134));
+
+        _sector->status =
+            (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    }
+};
+
+std::unique_ptr<Decoder> createZilogMczDecoder(const DecoderProto& config)
 {
-    readRawBits(14);
-
-    auto rawbits = readRawBits(140*16);
-    auto bytes = decodeFmMfm(rawbits).slice(0, 140);
-    ByteReader br(bytes);
-
-    _sector->logicalSector = br.read_8() & 0x1f;
-    _sector->logicalSide = 0;
-    _sector->logicalTrack = br.read_8() & 0x7f;
-    if (_sector->logicalSector > 31)
-        return;
-    if (_sector->logicalTrack > 80)
-        return;
-
-    _sector->data = br.read(132);
-    uint16_t wantChecksum = br.read_be16();
-    uint16_t gotChecksum = crc16(MODBUS_POLY, 0x0000, bytes.slice(0, 134));
-
-    _sector->status = (wantChecksum == gotChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
+    return std::unique_ptr<Decoder>(new ZilogMczDecoder(config));
 }