From 93443218d17ce1cb4f2e776f67a8f878480ffa63 Mon Sep 17 00:00:00 2001
From: sz <sz@recv.cc>
Date: Mon, 20 Mar 2023 21:27:07 -0500
Subject: [PATCH 1/3] Update ndk and targetSdkVersion in build.gradle

---
 app/build.gradle | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/app/build.gradle b/app/build.gradle
index 57921d3..c69bac9 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -3,13 +3,13 @@ apply plugin: 'com.android.application'
 android {
     compileSdkVersion 33
     buildToolsVersion "29.0.3"
-    ndkVersion "22.1.7171670"
+    ndkVersion "25.2.9519653"
     defaultConfig {
         applicationId "org.cimbar.camerafilecopy"
         minSdkVersion 21
-        targetSdkVersion 30
+        targetSdkVersion 33
         versionCode 8
-        versionName "0.5.12"
+        versionName "0.5.12+a"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
         externalNativeBuild {
             cmake {

From c1f74efcecfd4155775ff4aa17e48208b13df96e Mon Sep 17 00:00:00 2001
From: sz <sz@recv.cc>
Date: Sat, 24 Jun 2023 06:54:13 -0500
Subject: [PATCH 2/3] Squashed 'app/src/cpp/libcimbar/' changes from
 3cd792b5..f219e877

f219e877 Merge pull request #75 from sz3/web-fix
20f16012 The GL window height, or width, or both, needs to be divisible by 4?
98368d71 Pass dummy values to configure() to use config defaults
1b09a772 Use Config settings for cimbar_js defaults
b392e57b Pin the emscripten/emsdk docker image
d9bd2a29 Merge pull request #73 from sz3/bugfix-improve-and-5x5
709a3484 Add back a few test cases, add some comments, and check in the 5x5 tileset
b9d9d039 Simplify calculate_cooldown() + a comment for FloodDecodePositions::update()
55fcadb0 gh workflow updates
6baf0c43 Odd emscripten workaround -- not sure if this is the "right way", but it works
9f114732 Fix wasm packaging script
04528bb5 Add the 5x5 tileset to bitmaps.h + missing include
dce68331 Fix off-by-one type bug!
d452652b Update regression tests
8c891d01 Put back the Config.cpp for broader compiler support...
55956de1 Update more tests?
9204892a Misc fix
4d2943c1 Experimenting with ways to improve the flood decode
6daa9476 3,-5 for adaptiveThreshhold on symbols seems better?
18e54802 Put back the skip param for mean_rgb on larger cell sizes
1ec077b9 Running afoul of constexpr rules
4e33841c Put us back on 8x8
ec74f7c9 For now, put the uint128s back
02d4573e Have ahash_result take a template param for cell size
e2b55fce + do all bitextract index magic in "pattern()" function
24a291a2 Add some compile-time magic to auto-generate the bit extract pattern
173087ce Move grid params into their own file?
cad107cd Minor tweaks to make it easier to switch between grid sizes
f9326023 Special case for running the "ALL" check (9-way compare) on seed locations
92a33ef4 More warnings \o/
3479d39b Better(?) threshold params, and a thought
99e0f512 Drift cooldown?
f3cdabe9 More const, and add more seed positions for the decode?
6849234e These should all be const...
f9a9dd8a Scale window size off the size of the image.
3616c367 Pass image_size/anchor_size to extractor...
7766cfd8 Attempt to use 988x988 grid...?
c4f87506 A 5x5 that works with both 4 bit and 5 bit
c34ae889 Calculate total_cells() and frame capacity, and ...
cdd2f5c5 Update ahash_result for 5-bit reads + lots of test fixes for average_hash
ec629809 Changes to average_hash...
e2cab430 Small changes to average_hash(), decode_color()
731dfb1a Update the bitextractor to deal with reads other than len=8
1fd265d6 Minimal changes for encoding with a grid of 5x5s
b0aae780 Merge pull request #68 from sz3/packaging-cimbar-html
6ca0650f Post cimbar_js.html as part of package build.
0906f682 Script to bundle cimbar_js's asm.js build into a single html file
c8529e33 Merge pull request #63 from sz3/stdin
d17dcf31 -f is now the default
21f99327 A bit silly, but: py3.6 compatibility for now
2ff867d7 Test cli?
d646ec72 Have fountain_decoder_sink optionally print its work...
892579ae Have the encoder be stdin-aware too
21cc6a79 :thinking:
aad249d4 Read filenames from stdin iff no inputs are provided, + ...
074d813a Make fountain encoding the default. Add StdinLineReader for decodes.
89762c1e An idea

git-subtree-dir: app/src/cpp/libcimbar
git-subtree-split: f219e877652220702624e5ca06c5d1982060d0bb
---
 .github/workflows/ci.yml                      |  20 +-
 .github/workflows/release.yml                 |   5 +-
 CMakeLists.txt                                |   2 +-
 DETAILS.md                                    |   2 +-
 README.md                                     |   9 +-
 bitmap/2/00.png                               | Bin 0 -> 112 bytes
 bitmap/2/01.png                               | Bin 0 -> 113 bytes
 bitmap/2/02.png                               | Bin 0 -> 115 bytes
 bitmap/2/03.png                               | Bin 0 -> 114 bytes
 package-cimbar-html.py                        |  36 ++++
 package-portable-linux.sh                     |   2 +-
 package-wasm.sh                               |  11 +-
 .../build_image_assets/build_image_assets.cpp |  10 +-
 src/exe/cimbar/CMakeLists.txt                 |   1 +
 src/exe/cimbar/cimbar.cpp                     | 202 ++++++++++++++----
 src/exe/cimbar_extract/cimbar_extract.cpp     |   2 +-
 src/exe/cimbar_send/send.cpp                  |  14 +-
 src/lib/bit_file/bitmatrix.h                  |  36 ++--
 .../cimb_translator/AdjacentCellFinder.cpp    |  10 +-
 src/lib/cimb_translator/AdjacentCellFinder.h  |   8 +-
 src/lib/cimb_translator/Cell.h                |  24 +--
 src/lib/cimb_translator/CellDrift.cpp         |  16 +-
 src/lib/cimb_translator/CellDrift.h           |   5 +-
 src/lib/cimb_translator/CimbDecoder.cpp       |  45 ++--
 src/lib/cimb_translator/CimbDecoder.h         |   7 +-
 src/lib/cimb_translator/CimbReader.cpp        |  27 ++-
 src/lib/cimb_translator/CimbWriter.cpp        |   4 +-
 src/lib/cimb_translator/Config.cpp            |  84 ++------
 src/lib/cimb_translator/Config.h              | 121 +++++++++--
 .../cimb_translator/FloodDecodePositions.cpp  |  87 ++++++--
 .../cimb_translator/FloodDecodePositions.h    |  11 +-
 src/lib/cimb_translator/GridConf.h            |  31 +++
 src/lib/cimb_translator/bitmaps.h             |   5 +-
 .../cimb_translator/test/CimbDecoderTest.cpp  |  14 +-
 .../cimb_translator/test/CimbReaderTest.cpp   |  24 +--
 .../test/FloodDecodePositionsTest.cpp         |  46 +++-
 src/lib/cimbar_js/CMakeLists.txt              |   2 +-
 src/lib/cimbar_js/cimbar_js.cpp               |  18 +-
 src/lib/encoder/Decoder.h                     |  21 +-
 src/lib/encoder/SimpleEncoder.h               |  12 +-
 src/lib/encoder/reed_solomon_stream.h         |  27 ++-
 src/lib/encoder/test/DecoderTest.cpp          |   6 +-
 .../encoder/test/reed_solomon_streamTest.cpp  |  14 +-
 src/lib/extractor/Deskewer.cpp                |  11 +-
 src/lib/extractor/Deskewer.h                  |  14 +-
 src/lib/extractor/Extractor.cpp               |  13 +-
 src/lib/extractor/Extractor.h                 |   4 +-
 src/lib/extractor/test/DeskewerTest.cpp       |   2 +-
 src/lib/extractor/test/ExtractorTest.cpp      |   6 +-
 src/lib/extractor/test/UndistortTest.cpp      |   2 +-
 src/lib/fountain/fountain_decoder_sink.h      |  11 +-
 src/lib/image_hash/ahash_result.h             |  49 +++--
 src/lib/image_hash/average_hash.h             |  63 ++----
 src/lib/image_hash/bit_extractor.h            |  41 +++-
 src/lib/image_hash/test/averageHashTest.cpp   |  33 ++-
 src/lib/image_hash/test/bitExtractorTest.cpp  | 145 ++++++++++++-
 src/lib/image_hash/test/fuzzyAhashTest.cpp    | 116 ++++++++--
 test/py/__init__.py                           |   0
 test/py/helpers.py                            |  16 ++
 test/py/test_cimbar_cli.py                    |  89 ++++++++
 web/main.js                                   |   2 +-
 61 files changed, 1167 insertions(+), 471 deletions(-)
 create mode 100644 bitmap/2/00.png
 create mode 100644 bitmap/2/01.png
 create mode 100644 bitmap/2/02.png
 create mode 100644 bitmap/2/03.png
 create mode 100644 package-cimbar-html.py
 create mode 100644 src/lib/cimb_translator/GridConf.h
 create mode 100644 test/py/__init__.py
 create mode 100644 test/py/helpers.py
 create mode 100644 test/py/test_cimbar_cli.py

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 04301b7..ee21f6e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,20 +10,20 @@ jobs:
       fail-fast: false
       matrix:
         config:
-        - name: "linux gcc7"
-          os: ubuntu-18.04
-          env: CXX="g++-7" CC="gcc-7"
-
         - name: "linux gcc9"
+          os: ubuntu-20.04
+          env: CXX="g++-9" CC="gcc-9"
+
+        - name: "linux gcc-latest"
           os: ubuntu-latest
 
         - name: "linux clang"
-          os: ubuntu-18.04
+          os: ubuntu-20.04
           env: CXX="clang++" CC="clang"
           extra-packages: "clang"
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         submodules: 'recursive'
 
@@ -45,11 +45,15 @@ jobs:
       working-directory: ${{runner.workspace}}/build
       run: make test CTEST_OUTPUT_ON_FAILURE=TRUE
 
+    - name: Usage test
+      working-directory: ${{runner.workspace}}/libcimbar/test/py
+      run: python3 -m unittest
+
   cppcheck:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
 
     - name: Install dependencies
       run: sudo apt-get install cppcheck
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d7802ae..6903150 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           submodules: 'recursive'
 
@@ -23,7 +23,7 @@ jobs:
       - name: Run the build process with Docker
         uses: addnab/docker-run-action@v3
         with:
-          image: emscripten/emsdk:latest
+          image: emscripten/emsdk:3.1.39
           options: -v ${{ github.workspace }}:/usr/src/app
           shell: bash
           run: |
@@ -39,4 +39,5 @@ jobs:
           files: |
             web/cimbar.asmjs.zip
             web/cimbar.wasm.tar.gz
+            web/cimbar_js.html
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 13dcf5d..2010386 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ add_definitions("-DLIBCIMBAR_PROJECT_ROOT=\"${libcimbar_SOURCE_DIR}\"")
 if("${CMAKE_BUILD_TYPE}" STREQUAL "")
 	set(CMAKE_BUILD_TYPE "RelWithDebInfo")
 	set(CMAKE_C_FLAGS "${CFLAGS} -Wall -std=c99 -Os -fPIC")
-	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-Wall -g -O2 -fPIC")
+	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-Wall -Wextra -g -O2 -fPIC")
 endif()
 
 if(DEFINED USE_WASM)  # wasm build needs OPENCV_DIR defined
diff --git a/DETAILS.md b/DETAILS.md
index e58718f..d71d971 100644
--- a/DETAILS.md
+++ b/DETAILS.md
@@ -34,7 +34,7 @@ The above is a 4x4(x4) cimbar grid -- encoding 64 bits of data. A real cimbar im
 
 ![an example cimbar code](https://github.com/sz3/cimbar-samples/blob/v0.5/6bit/4color_ecc30_fountain_0.png)
 
-... and contains 1550 tiles for data. For 6-bit cimbar (4 symbol bits, 2 color bits), this means 9300 bytes per image.
+... and contains 12400 tiles for data. For 6-bit cimbar (4 symbol bits, 2 color bits), this means 9300 bytes per image.
 
 ### Error Correction
 
diff --git a/README.md b/README.md
index 2dc9e66..bfb0610 100644
--- a/README.md
+++ b/README.md
@@ -77,12 +77,17 @@ Encode:
 * large input files may fill up your disk with pngs!
 
 ```
-./cimbar --encode -i inputfile.txt -o outputprefix -f
+./cimbar --encode -i inputfile.txt -o outputprefix
 ```
 
 Decode (extracts file into output directory):
 ```
-./cimbar outputprefix*.png -o /tmp -f
+./cimbar outputprefix*.png -o /tmp
+```
+
+Decode a series of encoded images from stdin:
+```
+echo outputprefix*.png | ./cimbar -o /tmp
 ```
 
 Encode and animate to window:
diff --git a/bitmap/2/00.png b/bitmap/2/00.png
new file mode 100644
index 0000000000000000000000000000000000000000..8cd3d0e252f37f7fd5ac646d9c4524c425b9ef71
GIT binary patch
literal 112
zcmeAS@N?(olHy`uVBq!ia0vp^tRT$61|)m))t&+=&H|6fVg?4jBOuH;Rhv&5D5&J=
z;uyj)GdbnQ|Nr*PQVCAtKl=54$j7Q~lJt4O!~+BjH`cN<*OhLq1*&H7boFyt=akR{
E03#(E^Z)<=

literal 0
HcmV?d00001

diff --git a/bitmap/2/01.png b/bitmap/2/01.png
new file mode 100644
index 0000000000000000000000000000000000000000..b1b700f5e61340cab7ceaf887d9ddf72bcfa9c43
GIT binary patch
literal 113
zcmeAS@N?(olHy`uVBq!ia0vp^tRT$61|)m))t&+=&H|6fVg?4jBOuH;Rhv&5D5&h|
z;uyj)GdbnQ|NsB%*+LE+IRFG5z5=mLoRO@`W{xvh7^Y8U;d(8#dK*wVgQu&X%Q~lo
FCIGDC9|`~f

literal 0
HcmV?d00001

diff --git a/bitmap/2/02.png b/bitmap/2/02.png
new file mode 100644
index 0000000000000000000000000000000000000000..12269f4ebd4a800d8685947f89308b981728004a
GIT binary patch
literal 115
zcmeAS@N?(olHy`uVBq!ia0vp^tRT$61|)m))t&+=&H|6fVg?4jBOuH;Rhv&5D5&b`
z;uyj)GdbnQ|Nr*PQVE9y5)%><l7QG@dP0-ozhq&TX$%Z6=CU)#$t~dqYGCkm^>bP0
Hl+XkKiys{_

literal 0
HcmV?d00001

diff --git a/bitmap/2/03.png b/bitmap/2/03.png
new file mode 100644
index 0000000000000000000000000000000000000000..21302d445455b9ab5796d20b7dff933f303a1486
GIT binary patch
literal 114
zcmeAS@N?(olHy`uVBq!ia0vp^tRT$61|)m))t&+=&H|6fVg?4jBOuH;Rhv&5D5&D;
z;uyj)Gxp?0UIqq^!v@p;*XwC3EuOrsl<Qe@w`H;2ftm)^**{shXRFGH0@X8ky85}S
Ib4q9e09n`^{r~^~

literal 0
HcmV?d00001

diff --git a/package-cimbar-html.py b/package-cimbar-html.py
new file mode 100644
index 0000000..8246669
--- /dev/null
+++ b/package-cimbar-html.py
@@ -0,0 +1,36 @@
+
+def get_path(name):
+    fns = {
+        'index': 'web/index.html',
+        'cimbar_js': 'web/cimbar_js.js',
+        'main_js': 'web/main.js',
+        'output': 'web/cimbar_js.html',
+    }
+    return fns[name]
+
+
+def read_file(name):
+    with open(get_path(name), 'rt') as f:
+        return f.read()
+
+
+def read_script(name):
+    script = read_file(name)
+    return '<script type="text/javascript">\n' + script + '\n'
+
+
+def main():
+    contents = read_file('index')
+    main_js = read_script('main_js')
+    cimbar_js = read_script('cimbar_js')
+
+    contents = contents.replace('<script src="main.js">', main_js)
+    contents = contents.replace('<script src="cimbar_js.js">', cimbar_js)
+
+    with open(get_path('output'), 'wt') as f:
+        f.write(contents)
+
+
+
+if __name__ == '__main__':
+    main()
diff --git a/package-portable-linux.sh b/package-portable-linux.sh
index f1fb6a8..af2b51e 100644
--- a/package-portable-linux.sh
+++ b/package-portable-linux.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 ## targeting old glibc
 # docker run --mount type=bind,source="$(pwd)",target="/usr/src/app" -it ubuntu:16.04
 
diff --git a/package-wasm.sh b/package-wasm.sh
index 279da9b..58886a6 100644
--- a/package-wasm.sh
+++ b/package-wasm.sh
@@ -1,14 +1,14 @@
-#!/bin/sh
-#docker run --mount type=bind,source="$(pwd)",target="/usr/src/app" -it emscripten/emsdk:latest
+#!/bin/bash
+#docker run --mount type=bind,source="$(pwd)",target="/usr/src/app" -it emscripten/emsdk:3.1.39
 
 cd /usr/src/app
 
 apt update
-apt install python -y
+apt install python3 -y
 
 cd opencv4/
 mkdir opencv-build-wasm && cd opencv-build-wasm
-python ../platforms/js/build_js.py build_wasm --build_wasm --emscripten_dir=/emsdk/upstream/emscripten
+python3 ../platforms/js/build_js.py build_wasm --build_wasm --emscripten_dir=/emsdk/upstream/emscripten
 
 cd /usr/src/app
 mkdir build-wasm && cd build-wasm
@@ -21,3 +21,6 @@ mkdir build-asmjs && cd build-asmjs
 emcmake cmake .. -DUSE_WASM=2 -DOPENCV_DIR=/usr/src/app/opencv4
 make -j5 install
 (cd ../web/ && zip cimbar.asmjs.zip cimbar_js.js index.html main.js)
+
+(cd ../ && python3 package-cimbar-html.py)
+
diff --git a/src/exe/build_image_assets/build_image_assets.cpp b/src/exe/build_image_assets/build_image_assets.cpp
index a756573..bc7a563 100644
--- a/src/exe/build_image_assets/build_image_assets.cpp
+++ b/src/exe/build_image_assets/build_image_assets.cpp
@@ -29,6 +29,12 @@ map<string, string> getFileBlobs(string dir_path)
 			blobs[file_path] = base91::encode(contents);
 		}
 
+	for (int i = 0; i < 4; ++i)
+	{
+		string file_path = fmt::format("{}/2/{:02x}.png", dir_path, i);
+		string contents = File(file_path).read_all();
+		blobs[file_path] = base91::encode(contents);
+	}
 	for (int i = 0; i < 16; ++i)
 	{
 		string file_path = fmt::format("{}/4/{:02x}.png", dir_path, i);
@@ -43,8 +49,8 @@ int main(int argc, char** argv)
 	cxxopts::Options options("build_image_assets", "Build a C++ class file (header-only) that contains base91 png asset data.");
 
 	options.add_options()
-	    ("b,bitmap", "Bitmap directory", cxxopts::value<std::string>())
-	    ("h,help", "Print usage")
+		("b,bitmap", "Bitmap directory", cxxopts::value<std::string>())
+		("h,help", "Print usage")
 	;
 
 	auto result = options.parse(argc, argv);
diff --git a/src/exe/cimbar/CMakeLists.txt b/src/exe/cimbar/CMakeLists.txt
index c1b3d1d..d15b563 100644
--- a/src/exe/cimbar/CMakeLists.txt
+++ b/src/exe/cimbar/CMakeLists.txt
@@ -20,6 +20,7 @@ target_link_libraries(cimbar
 	wirehair
 	zstd
 	${OPENCV_LIBS}
+	${CPPFILESYSTEM}
 )
 
 add_custom_command(
diff --git a/src/exe/cimbar/cimbar.cpp b/src/exe/cimbar/cimbar.cpp
index 8f8c91e..a282769 100644
--- a/src/exe/cimbar/cimbar.cpp
+++ b/src/exe/cimbar/cimbar.cpp
@@ -12,6 +12,8 @@
 
 #include "cxxopts/cxxopts.hpp"
 
+#include <cstdio>
+#include <experimental/filesystem>
 #include <functional>
 #include <iostream>
 #include <string>
@@ -19,11 +21,109 @@
 using std::string;
 using std::vector;
 
-int decode(const vector<string>& infiles, const std::function<int(cv::UMat, bool, bool)>& decode, bool no_deskew, bool undistort, int preprocess, bool color_correct)
+namespace {
+	class stdinerator
+	{
+	public:
+		stdinerator(bool done=false)
+			: _done(done)
+		{
+			read_once();
+		}
+
+		void mark_done()
+		{
+			_done = true;
+		}
+
+		void read_once()
+		{
+			if (_done)
+				return;
+
+			if (::feof(::stdin))
+			{
+				mark_done();
+				return;
+			}
+
+			std::getline(std::cin, _current);
+		}
+
+		std::string operator*() const
+		{
+			return _current;
+		}
+
+		stdinerator& operator++()
+		{
+			read_once();
+			return *this;
+		}
+
+		bool operator==(const stdinerator& rhs) const
+		{
+			return _done and rhs._done;
+		}
+
+		bool operator!=(const stdinerator& rhs) const
+		{
+			return !operator==(rhs);
+		}
+
+		static stdinerator begin()
+		{
+			return stdinerator();
+		}
+
+		static stdinerator end()
+		{
+			return stdinerator(true);
+		}
+
+	protected:
+		bool _done = false;
+		std::string _current;
+	};
+
+	struct StdinLineReader
+	{
+		stdinerator begin() const
+		{
+			return stdinerator::begin();
+		}
+
+		stdinerator end() const
+		{
+			return stdinerator::end();
+		}
+	};
+}
+
+template <typename FilenameIterable>
+int encode(const FilenameIterable& infiles, const std::string& outpath, int ecc, int color_bits, int compression_level, bool no_fountain)
+{
+	Encoder en(ecc, cimbar::Config::symbol_bits(), color_bits);
+	for (const string& f : infiles)
+	{
+		if (f.empty())
+			continue;
+		if (no_fountain)
+			en.encode(f, outpath);
+		else
+			en.encode_fountain(f, outpath, compression_level);
+	}
+	return 0;
+}
+
+template <typename FilenameIterable>
+int decode(const FilenameIterable& infiles, const std::function<int(cv::UMat, bool, bool)>& decode, bool no_deskew, bool undistort, int preprocess, bool color_correct)
 {
 	int err = 0;
 	for (const string& inf : infiles)
 	{
+		if (inf.empty())
+			continue;
 		bool shouldPreprocess = (preprocess == 1);
 		cv::UMat img = cv::imread(inf).getUMat(cv::ACCESS_RW);
 		cv::cvtColor(img, img, cv::COLOR_BGR2RGB);
@@ -73,51 +173,55 @@ int main(int argc, char** argv)
 	unsigned compressionLevel = cimbar::Config::compression_level();
 	unsigned ecc = cimbar::Config::ecc_bytes();
 	options.add_options()
-	    ("i,in", "Encoded pngs/jpgs/etc (for decode), or file to encode", cxxopts::value<vector<string>>())
-	    ("o,out", "Output file prefix (encoding) or directory (decoding).", cxxopts::value<string>())
-	    ("c,color-bits", "Color bits. [0-3]", cxxopts::value<int>()->default_value(turbo::str::str(colorBits)))
-	    ("e,ecc", "ECC level", cxxopts::value<unsigned>()->default_value(turbo::str::str(ecc)))
-	    ("f,fountain", "Attempt fountain encode/decode", cxxopts::value<bool>())
-	    ("z,compression", "Compression level. 0 == no compression.", cxxopts::value<int>()->default_value(turbo::str::str(compressionLevel)))
-	    ("color-correct", "Toggle decoding color correction. 1 == on. 0 == off.", cxxopts::value<int>()->default_value("1"))
-	    ("encode", "Run the encoder!", cxxopts::value<bool>())
-	    ("no-deskew", "Skip the deskew step -- treat input image as already extracted.", cxxopts::value<bool>())
-	    ("undistort", "Attempt undistort step -- useful if image distortion is significant.", cxxopts::value<bool>())
-	    ("preprocess", "Run sharpen filter on the input image. 1 == on. 0 == off. -1 == guess.", cxxopts::value<int>()->default_value("-1"))
-	    ("h,help", "Print usage")
+		("i,in", "Encoded pngs/jpgs/etc (for decode), or file to encode", cxxopts::value<vector<string>>())
+		("o,out", "Output file prefix (encoding) or directory (decoding).", cxxopts::value<string>())
+		("c,color-bits", "Color bits. [0-3]", cxxopts::value<int>()->default_value(turbo::str::str(colorBits)))
+		("e,ecc", "ECC level", cxxopts::value<unsigned>()->default_value(turbo::str::str(ecc)))
+		("z,compression", "Compression level. 0 == no compression.", cxxopts::value<int>()->default_value(turbo::str::str(compressionLevel)))
+		("color-correct", "Toggle decoding color correction. 1 == on. 0 == off.", cxxopts::value<int>()->default_value("1"))
+		("encode", "Run the encoder!", cxxopts::value<bool>())
+		("no-deskew", "Skip the deskew step -- treat input image as already extracted.", cxxopts::value<bool>())
+		("no-fountain", "Disable fountain encode/decode. Will also disable compression.", cxxopts::value<bool>())
+		("undistort", "Attempt undistort step -- useful if image distortion is significant.", cxxopts::value<bool>())
+		("preprocess", "Run sharpen filter on the input image. 1 == on. 0 == off. -1 == guess.", cxxopts::value<int>()->default_value("-1"))
+		("h,help", "Print usage")
 	;
 	options.show_positional_help();
 	options.parse_positional({"in"});
 	options.positional_help("<in...>");
 
 	auto result = options.parse(argc, argv);
-	if (result.count("help") or !result.count("out") or !result.count("in"))
+	if (result.count("help"))
 	{
-	  std::cout << options.help() << std::endl;
-	  exit(0);
+		std::cerr << options.help() << std::endl;
+		exit(0);
 	}
 
-	vector<string> infiles = result["in"].as<vector<string>>();
-	string outpath = result["out"].as<string>();
+	string outpath = std::experimental::filesystem::current_path();
+	if (result.count("out"))
+		outpath = result["out"].as<string>();
+	std::cerr << "Output files will appear in " << outpath << std::endl;
 
-	bool encode = result.count("encode");
-	bool fountain = result.count("fountain");
+	bool useStdin = !result.count("in");
+	vector<string> infiles;
+	if (useStdin)
+		std::cerr << "Enter input filenames:" << std::endl;
+	else
+		infiles = result["in"].as<vector<string>>();
+
+	bool encodeFlag = result.count("encode");
+	bool no_fountain = result.count("no-fountain");
 
 	colorBits = std::min(3, result["color-bits"].as<int>());
 	compressionLevel = result["compression"].as<int>();
 	ecc = result["ecc"].as<unsigned>();
 
-	if (encode)
+	if (encodeFlag)
 	{
-		Encoder en(ecc, cimbar::Config::symbol_bits(), colorBits);
-		for (const string& f : infiles)
-		{
-			if (fountain)
-				en.encode_fountain(f, outpath, compressionLevel);
-			else
-				en.encode(f, outpath);
-		}
-		return 0;
+		if (useStdin)
+			return encode(StdinLineReader(), outpath, ecc, colorBits, compressionLevel, no_fountain);
+		else
+			return encode(infiles, outpath, ecc, colorBits, compressionLevel, no_fountain);
 	}
 
 	// else, decode
@@ -128,24 +232,32 @@ int main(int argc, char** argv)
 
 	Decoder d(ecc, colorBits);
 
-	if (fountain)
+	if (no_fountain)
 	{
-		unsigned chunkSize = cimbar::Config::fountain_chunk_size(ecc);
-		if (compressionLevel <= 0)
-		{
-			fountain_decoder_sink<std::ofstream> sink(outpath, chunkSize);
-			return decode(infiles, fountain_decode_fun(sink, d), no_deskew, undistort, preprocess, color_correct);
-		}
+		// simpler encoding, just the basics + ECC. No compression, fountain codes, etc.
+		std::ofstream f(outpath);
+		std::function<int(cv::UMat,bool,bool)> fun = [&f, &d] (cv::UMat m, bool pre, bool cc) {
+			return d.decode(m, f, pre, cc);
+		};
+		if (useStdin)
+			return decode(StdinLineReader(), fun, no_deskew, undistort, preprocess, color_correct);
+		else
+			return decode(infiles, fun, no_deskew, undistort, preprocess, color_correct);
+	}
 
-		// else -- default case, all bells and whistles
-		fountain_decoder_sink<cimbar::zstd_decompressor<std::ofstream>> sink(outpath, chunkSize);
+	// else, the good stuff
+	unsigned chunkSize = cimbar::Config::fountain_chunk_size(ecc);
+	if (compressionLevel <= 0)
+	{
+		fountain_decoder_sink<std::ofstream> sink(outpath, chunkSize, true);
 		return decode(infiles, fountain_decode_fun(sink, d), no_deskew, undistort, preprocess, color_correct);
 	}
 
-	// else
-	std::ofstream f(outpath);
-	std::function<int(cv::UMat,bool,bool)> fun = [&f, &d] (cv::UMat m, bool pre, bool cc) {
-		return d.decode(m, f, pre, cc);
-	};
-	return decode(infiles, fun, no_deskew, undistort, preprocess, color_correct);
+	// else -- default case, all bells and whistles
+	fountain_decoder_sink<cimbar::zstd_decompressor<std::ofstream>> sink(outpath, chunkSize, true);
+
+	if (useStdin)
+		return decode(StdinLineReader(), fountain_decode_fun(sink, d), no_deskew, undistort, preprocess, color_correct);
+	else
+		return decode(infiles, fountain_decode_fun(sink, d), no_deskew, undistort, preprocess, color_correct);
 }
diff --git a/src/exe/cimbar_extract/cimbar_extract.cpp b/src/exe/cimbar_extract/cimbar_extract.cpp
index e2adb32..8e8b6ce 100644
--- a/src/exe/cimbar_extract/cimbar_extract.cpp
+++ b/src/exe/cimbar_extract/cimbar_extract.cpp
@@ -8,7 +8,7 @@ using std::string;
 
 int main(int argc, char** argv)
 {
-	cxxopts::Options options("cimbar scan", "Scan/extract cimbar code from a source image.");
+	cxxopts::Options options("cimbar_extract", "Scan/extract cimbar code from a source image.");
 
 	options.add_options()
 	    ("i,in", "Encoded png/jpg/etc", cxxopts::value<std::string>())
diff --git a/src/exe/cimbar_send/send.cpp b/src/exe/cimbar_send/send.cpp
index 4cb3c40..753bf1d 100644
--- a/src/exe/cimbar_send/send.cpp
+++ b/src/exe/cimbar_send/send.cpp
@@ -38,12 +38,12 @@ int main(int argc, char** argv)
 	unsigned ecc = cimbar::Config::ecc_bytes();
 	unsigned defaultFps = 15;
 	options.add_options()
-	    ("i,in", "Source file", cxxopts::value<vector<string>>())
-	    ("c,colorbits", "Color bits. [0-3]", cxxopts::value<int>()->default_value(turbo::str::str(colorBits)))
-	    ("e,ecc", "ECC level", cxxopts::value<unsigned>()->default_value(turbo::str::str(ecc)))
-	    ("f,fps", "Target FPS", cxxopts::value<unsigned>()->default_value(turbo::str::str(defaultFps)))
-	    ("z,compression", "Compression level. 0 == no compression.", cxxopts::value<int>()->default_value(turbo::str::str(compressionLevel)))
-	    ("h,help", "Print usage")
+		("i,in", "Source file", cxxopts::value<vector<string>>())
+		("c,colorbits", "Color bits. [0-3]", cxxopts::value<int>()->default_value(turbo::str::str(colorBits)))
+		("e,ecc", "ECC level", cxxopts::value<unsigned>()->default_value(turbo::str::str(ecc)))
+		("f,fps", "Target FPS", cxxopts::value<unsigned>()->default_value(turbo::str::str(defaultFps)))
+		("z,compression", "Compression level. 0 == no compression.", cxxopts::value<int>()->default_value(turbo::str::str(compressionLevel)))
+		("h,help", "Print usage")
 	;
 	options.show_positional_help();
 	options.parse_positional({"in"});
@@ -66,7 +66,7 @@ int main(int argc, char** argv)
 		fps = defaultFps;
 	unsigned delay = 1000 / fps;
 
-	int window_size = 1080;
+	int window_size = cimbar::Config::image_size() + 32;
 	if (!initialize_GL(window_size, window_size))
 	{
 		std::cerr << "failed to create window :(" << std::endl;
diff --git a/src/lib/bit_file/bitmatrix.h b/src/lib/bit_file/bitmatrix.h
index c43baee..bafa904 100644
--- a/src/lib/bit_file/bitmatrix.h
+++ b/src/lib/bit_file/bitmatrix.h
@@ -17,33 +17,41 @@ class bitmatrix
 		unsigned size = img.cols * img.rows;
 		while (size >= 8)
 		{
-			const uint64_t* hax = reinterpret_cast<const uint64_t*>(p);
-			uint64_t mval = (*hax) & 0x101010101010101ULL;
+			// we're turning 1 uint64_t into 8 uint8_ts
+			uint64_t mval;
+			memcpy(&mval, p, sizeof mval);
+			mval = mval & 0x101010101010101ULL;
 			const uint8_t* cv = reinterpret_cast<const uint8_t*>(&mval);
-			uint8_t val = cv[0] << 7 | cv[1] << 6 | cv[2] << 5 | cv[3] << 4 | cv[4] << 3 | cv[5] << 2 | cv[6] << 1 | cv[7];
+			// TODO: what about endianness???
+			uint8_t val = (
+				cv[0] << 7 | cv[1] << 6 | cv[2] << 5 | cv[3] << 4 | cv[4] << 3 | cv[5] << 2 |
+				cv[6] << 1 | cv[7]
+			);
 			writer << val;
 			p += 8;
 			size -= 8;
 		}
 
 		// remainder
-		uint8_t val = 0;
-		while (size > 0)
+		if (size > 0)
 		{
-			val |= (*p > 0) << size;
-			++p;
-			--size;
+			uint8_t val = 0;
+			while (size > 0) {
+				val |= (*p > 0) << size;
+				++p;
+				--size;
+			}
+			writer << val;
 		}
-		writer << val;
 	}
 
 public:
 	bitmatrix(const bitbuffer& buff, unsigned width, unsigned height, unsigned xstart=0, unsigned ystart=0)
-	    : _buff(buff)
-	    , _xstart(xstart)
-	    , _ystart(ystart)
-	    , _width(width)
-	    , _height(height)
+		: _buff(buff)
+		, _xstart(xstart)
+		, _ystart(ystart)
+		, _width(width)
+		, _height(height)
 	{
 	}
 
diff --git a/src/lib/cimb_translator/AdjacentCellFinder.cpp b/src/lib/cimb_translator/AdjacentCellFinder.cpp
index c27b480..49dbba7 100644
--- a/src/lib/cimb_translator/AdjacentCellFinder.cpp
+++ b/src/lib/cimb_translator/AdjacentCellFinder.cpp
@@ -2,9 +2,9 @@
 #include "AdjacentCellFinder.h"
 
 AdjacentCellFinder::AdjacentCellFinder(const CellPositions::positions_list& positions, int dimensions, int marker_size)
-    : _positions(positions)
-    , _dimensions(dimensions)
-    , _markerSize(marker_size)
+	: _positions(positions)
+	, _dimensions(dimensions)
+	, _markerSize(marker_size)
 {
 	int midDimensions = dimensions - marker_size - marker_size;
 	int midCells = dimensions * midDimensions;
@@ -13,10 +13,10 @@ AdjacentCellFinder::AdjacentCellFinder(const CellPositions::positions_list& posi
 	_firstBottom = edgeCells + midCells;
 }
 
-std::array<int, 4> AdjacentCellFinder::find(int index)
+std::array<int, 4> AdjacentCellFinder::find(int index) const
 {
 	std::array<int,4> adj = {
-	    right(index), left(index), bottom(index), top(index)
+		right(index), left(index), bottom(index), top(index)
 	};
 	return adj;
 }
diff --git a/src/lib/cimb_translator/AdjacentCellFinder.h b/src/lib/cimb_translator/AdjacentCellFinder.h
index 6b89442..287a913 100644
--- a/src/lib/cimb_translator/AdjacentCellFinder.h
+++ b/src/lib/cimb_translator/AdjacentCellFinder.h
@@ -9,19 +9,19 @@ class AdjacentCellFinder
 public:
 	AdjacentCellFinder(const CellPositions::positions_list& positions, int dimensions, int marker_size);
 
-	std::array<int, 4> find(int index);
+	std::array<int, 4> find(int index) const;
 
 	int dimensions() const;
 	int marker_size() const;
 
-protected:
-	int in_row_with_margin(int index) const;
-
 	int right(int index) const;
 	int left(int index) const;
 	int bottom(int index) const;
 	int top(int index) const;
 
+protected:
+	int in_row_with_margin(int index) const;
+
 protected:
 	const CellPositions::positions_list& _positions;
 	int _dimensions;
diff --git a/src/lib/cimb_translator/Cell.h b/src/lib/cimb_translator/Cell.h
index 3595160..3ce65a7 100644
--- a/src/lib/cimb_translator/Cell.h
+++ b/src/lib/cimb_translator/Cell.h
@@ -12,22 +12,22 @@ class Cell
 
 public:
 	Cell(const cv::Mat& img)
-	    : _img(img)
-	    , _cols(img.cols)
-	    , _rows(img.rows)
+		: _img(img)
+		, _cols(img.cols)
+		, _rows(img.rows)
 	{
 	}
 
 	Cell(const cv::Mat& img, int xstart, int ystart, int cols, int rows)
-	    : _img(img)
-	    , _xstart(xstart)
-	    , _ystart(ystart)
-	    , _cols(cols)
-	    , _rows(rows)
+		: _img(img)
+		, _xstart(xstart)
+		, _ystart(ystart)
+		, _cols(cols)
+		, _rows(rows)
 	{}
 
 	// it would be nice to use a cropped cv::Mat to get the contiguous memory pointer...
-	std::tuple<uchar,uchar,uchar> mean_rgb_continuous(bool skip)
+	std::tuple<uchar,uchar,uchar> mean_rgb_continuous(bool skip) const
 	{
 		uint16_t blue = 0;
 		uint16_t green = 0;
@@ -61,7 +61,7 @@ class Cell
 		return std::tuple<uchar,uchar,uchar>(red/count, green/count, blue/count);
 	}
 
-	std::tuple<uchar,uchar,uchar> mean_rgb(bool skip=false)
+	std::tuple<uchar,uchar,uchar> mean_rgb(bool skip=false) const
 	{
 		int channels = _img.channels();
 		if (channels < 3)
@@ -93,7 +93,7 @@ class Cell
 		return std::tuple<uchar,uchar,uchar>(red/count, green/count, blue/count);
 	}
 
-	uchar mean_grayscale_continuous()
+	uchar mean_grayscale_continuous() const
 	{
 		uint16_t total = 0;
 		uint16_t count = 0;
@@ -114,7 +114,7 @@ class Cell
 		return (uchar)(total/count);
 	}
 
-	uchar mean_grayscale()
+	uchar mean_grayscale() const
 	{
 		if (_img.channels() > 1)
 			return 0;
diff --git a/src/lib/cimb_translator/CellDrift.cpp b/src/lib/cimb_translator/CellDrift.cpp
index bec89b7..e92926f 100644
--- a/src/lib/cimb_translator/CellDrift.cpp
+++ b/src/lib/cimb_translator/CellDrift.cpp
@@ -6,8 +6,8 @@ namespace {
 }
 
 CellDrift::CellDrift(int x, int y)
-    : _x(x)
-    , _y(y)
+	: _x(x)
+	, _y(y)
 {}
 
 int CellDrift::x() const
@@ -29,3 +29,15 @@ void CellDrift::updateDrift(int dx, int dy)
 	_y = std::min(_y, _limit);
 	_y = std::max(_y, 0-_limit);
 }
+
+// static
+uint8_t CellDrift::calculate_cooldown(uint8_t previous, uint8_t idx)
+{
+	if (idx == 4)
+		return 4;
+	if (idx % 2 == 0)
+		return 0xFF;
+	if ((previous xor idx) == 6) // 1 and 7, 3 and 5
+		return 0xFF;
+	return idx;
+}
diff --git a/src/lib/cimb_translator/CellDrift.h b/src/lib/cimb_translator/CellDrift.h
index d0f3766..d29ad54 100644
--- a/src/lib/cimb_translator/CellDrift.h
+++ b/src/lib/cimb_translator/CellDrift.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include <array>
+#include <cstdint>
 #include <utility>
 
 class CellDrift
@@ -10,9 +11,11 @@ class CellDrift
 	CellDrift(int x=0, int y=0);
 
 	inline static const std::array<std::pair<int, int>, 9> driftPairs = {{
-	    {-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {0, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}
+		{-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {0, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}
 	}};
 
+	static uint8_t calculate_cooldown(uint8_t previous, uint8_t idx);
+
 	int x() const;
 	int y() const;
 
diff --git a/src/lib/cimb_translator/CimbDecoder.cpp b/src/lib/cimb_translator/CimbDecoder.cpp
index 424a068..83db22f 100644
--- a/src/lib/cimb_translator/CimbDecoder.cpp
+++ b/src/lib/cimb_translator/CimbDecoder.cpp
@@ -1,8 +1,9 @@
 /* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
 #include "CimbDecoder.h"
 
-#include "Common.h"
 #include "Cell.h"
+#include "Common.h"
+#include "Config.h"
 #include "image_hash/hamming_distance.h"
 #include "serialize/format.h"
 
@@ -43,19 +44,19 @@ namespace {
 		std::tuple<int,int,int> rel1 = relative_color(a);
 		std::tuple<int,int,int> rel2 = relative_color(b);
 		return (
-		    squared_difference(std::get<0>(rel1), std::get<0>(rel2)) +
-		    squared_difference(std::get<1>(rel1), std::get<1>(rel2)) +
-		    squared_difference(std::get<2>(rel1), std::get<2>(rel2))
+			squared_difference(std::get<0>(rel1), std::get<0>(rel2)) +
+			squared_difference(std::get<1>(rel1), std::get<1>(rel2)) +
+			squared_difference(std::get<2>(rel1), std::get<2>(rel2))
 		);
 	}
 }
 
 CimbDecoder::CimbDecoder(unsigned symbol_bits, unsigned color_bits, bool dark, uchar ahashThreshold)
-    : _symbolBits(symbol_bits)
-    , _numSymbols(1 << symbol_bits)
-    , _numColors(1 << color_bits)
-    , _dark(dark)
-    , _ahashThreshold(ahashThreshold)
+	: _symbolBits(symbol_bits)
+	, _numSymbols(1 << symbol_bits)
+	, _numColors(1 << color_bits)
+	, _dark(dark)
+	, _ahashThreshold(ahashThreshold)
 {
 	load_tiles();
 }
@@ -79,7 +80,7 @@ bool CimbDecoder::load_tiles()
 	return true;
 }
 
-unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result& results, unsigned& drift_offset, unsigned& best_distance) const
+unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result<cimbar::Config::cell_size()>& results, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown) const
 {
 	drift_offset = 0;
 	unsigned best_fit = 0;
@@ -91,6 +92,11 @@ unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result& results, unsigne
 	// 8, 0, 2, 6 == corners.
 	for (auto&& [drift_idx, h] : results)
 	{
+		// skip over this drift_idx if it matches cooldown
+		// we could be more clever to check for corners, but for now this is fine
+		// ~0U is "unset"
+		if (drift_idx == cooldown and drift_idx != 4) // don't skip the center, obvs
+			continue;
 		for (unsigned i = 0; i < _tileHashes.size(); ++i)
 		{
 			unsigned distance = image_hash::hamming_distance(h, _tileHashes[i]);
@@ -107,16 +113,19 @@ unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result& results, unsigne
 	return best_fit;
 }
 
-unsigned CimbDecoder::decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance) const
+unsigned CimbDecoder::decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown) const
 {
-	image_hash::ahash_result results = image_hash::fuzzy_ahash(cell, _ahashThreshold, image_hash::ahash_result::FAST);
-	return get_best_symbol(results, drift_offset, best_distance);
+	image_hash::ahash_result<cimbar::Config::cell_size()> results = image_hash::fuzzy_ahash<cimbar::Config::cell_size()>(
+		cell, _ahashThreshold, image_hash::ahash_result<cimbar::Config::cell_size()>::FAST
+	);
+	return get_best_symbol(results, drift_offset, best_distance, cooldown);
 }
 
-unsigned CimbDecoder::decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance) const
+unsigned CimbDecoder::decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown) const
 {
-	image_hash::ahash_result results = image_hash::fuzzy_ahash(cell, image_hash::ahash_result::FAST);
-	return get_best_symbol(results, drift_offset, best_distance);
+	int checkRule = cooldown == 0xFE? image_hash::ahash_result<cimbar::Config::cell_size()>::ALL : image_hash::ahash_result<cimbar::Config::cell_size()>::FAST;
+	image_hash::ahash_result<cimbar::Config::cell_size()> results = image_hash::fuzzy_ahash<cimbar::Config::cell_size()>(cell, checkRule);
+	return get_best_symbol(results, drift_offset, best_distance, cooldown);
 }
 
 std::tuple<uchar,uchar,uchar> CimbDecoder::fix_color(std::tuple<float,float,float> c, float adjustUp, float down) const
@@ -174,10 +183,10 @@ unsigned CimbDecoder::decode_color(const Cell& color_cell) const
 		return 0;
 
 	// TODO: check/enforce dimensions of color_cell?
-	// limit dimensions to ignore outer row/col. We want to look at the middle 6x6
+	// limit dimensions to ignore outer row/col. We want to look at the middle 6x6, or 3x3...
 	Cell center = color_cell;
 	center.crop(1, 1, color_cell.cols()-2, color_cell.rows()-2);
-	auto [r, g, b] = center.mean_rgb(Cell::SKIP);
+	auto [r, g, b] = center.mean_rgb(center.cols() > 4? Cell::SKIP : 0);
 	return get_best_color(r, g, b);
 }
 
diff --git a/src/lib/cimb_translator/CimbDecoder.h b/src/lib/cimb_translator/CimbDecoder.h
index 517a983..681c671 100644
--- a/src/lib/cimb_translator/CimbDecoder.h
+++ b/src/lib/cimb_translator/CimbDecoder.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include "CellDrift.h"
+#include "Config.h"
 #include "chromatic_adaptation/color_correction.h"
 #include "image_hash/ahash_result.h"
 #include "image_hash/average_hash.h"
@@ -16,9 +17,9 @@ class CimbDecoder
 
 	void update_color_correction(cv::Matx<float, 3, 3>&& ccm);
 
-	unsigned get_best_symbol(image_hash::ahash_result& results, unsigned& drift_offset, unsigned& best_distance) const;
-	unsigned decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance) const;
-	unsigned decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance) const;
+	unsigned get_best_symbol(image_hash::ahash_result<cimbar::Config::cell_size()>& results, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown=0xFF) const;
+	unsigned decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown=0xFF) const;
+	unsigned decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown=0xFF) const;
 
 	unsigned get_best_color(float r, float g, float b) const;
 	unsigned decode_color(const Cell& cell) const;
diff --git a/src/lib/cimb_translator/CimbReader.cpp b/src/lib/cimb_translator/CimbReader.cpp
index ca30327..5a3f7eb 100644
--- a/src/lib/cimb_translator/CimbReader.cpp
+++ b/src/lib/cimb_translator/CimbReader.cpp
@@ -32,13 +32,10 @@ namespace {
 		cv::Mat symbols;
 		cv::cvtColor(img, symbols, cv::COLOR_RGB2GRAY);
 		if (needs_sharpen)
-		{
-			sharpenSymbolGrid(symbols, symbols);
-			blockSize = 7;
-		}
-		cv::adaptiveThreshold(symbols, symbols, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, blockSize, 0);
+			sharpenSymbolGrid(symbols, symbols); // we used to change blockSize for this case -- may one day be a useful trick again?
+		cv::adaptiveThreshold(symbols, symbols, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, blockSize, -5);
 
-		bitbuffer bb(1024*128);
+		bitbuffer bb(std::pow(Config::image_size(), 2) / 8);
 		bitmatrix::mat_to_bitbuffer(symbols, bb.get_writer());
 		return bb;
 	}
@@ -89,11 +86,11 @@ namespace {
 }
 
 CimbReader::CimbReader(const cv::Mat& img, CimbDecoder& decoder, bool needs_sharpen, bool color_correction)
-    : _image(img)
-    , _cellSize(Config::cell_size() + 2)
-    , _positions(Config::cell_spacing(), Config::num_cells(), Config::cell_size(), Config::corner_padding())
-    , _decoder(decoder)
-    , _good(_image.cols >= Config::image_size() and _image.rows >= Config::image_size())
+	: _image(img)
+	, _cellSize(Config::cell_size() + 2)
+	, _positions(Config::cell_spacing(), Config::cells_per_col(), Config::cell_offset(), Config::corner_padding())
+	, _decoder(decoder)
+	, _good(_image.cols >= Config::image_size() and _image.rows >= Config::image_size())
 {
 	_grayscale = preprocessSymbolGrid(img, needs_sharpen);
 	if (_good and color_correction)
@@ -101,7 +98,7 @@ CimbReader::CimbReader(const cv::Mat& img, CimbDecoder& decoder, bool needs_shar
 }
 
 CimbReader::CimbReader(const cv::UMat& img, CimbDecoder& decoder, bool needs_sharpen, bool color_correction)
-    : CimbReader(img.getMat(cv::ACCESS_READ), decoder, needs_sharpen, color_correction)
+	: CimbReader(img.getMat(cv::ACCESS_READ), decoder, needs_sharpen, color_correction)
 {
 }
 
@@ -117,18 +114,18 @@ unsigned CimbReader::read(PositionData& pos)
 		return 0;
 
 	// need coordinate, index, and drift from next position
-	auto [i, xy, drift] = _positions.next();
+	auto [i, xy, drift, cooldown] = _positions.next();
 	int x = xy.first + drift.x();
 	int y = xy.second + drift.y();
 	bitmatrix cell(_grayscale, _image.cols, _image.rows, x-1, y-1);
 
 	unsigned drift_offset = 0;
 	unsigned error_distance;
-	unsigned bits = _decoder.decode_symbol(cell, drift_offset, error_distance);
+	unsigned bits = _decoder.decode_symbol(cell, drift_offset, error_distance, cooldown);
 
 	std::pair<int, int> best_drift = CellDrift::driftPairs[drift_offset];
 	drift.updateDrift(best_drift.first, best_drift.second);
-	_positions.update(i, drift, error_distance);
+	_positions.update(i, drift, error_distance, CellDrift::calculate_cooldown(cooldown, drift_offset));
 
 	pos.i = i;
 	pos.x = x + best_drift.first;
diff --git a/src/lib/cimb_translator/CimbWriter.cpp b/src/lib/cimb_translator/CimbWriter.cpp
index bb021ef..dc33026 100644
--- a/src/lib/cimb_translator/CimbWriter.cpp
+++ b/src/lib/cimb_translator/CimbWriter.cpp
@@ -36,8 +36,8 @@ namespace {
 }
 
 CimbWriter::CimbWriter(unsigned symbol_bits, unsigned color_bits, bool dark, int size)
-    : _positions(Config::cell_spacing(), Config::num_cells(), Config::cell_size(), Config::corner_padding(), Config::interleave_blocks(), Config::interleave_partitions())
-    , _encoder(symbol_bits, color_bits)
+	: _positions(Config::cell_spacing(), Config::cells_per_col(), Config::cell_offset(), Config::corner_padding(), Config::interleave_blocks(), Config::interleave_partitions())
+	, _encoder(symbol_bits, color_bits)
 {
 	if (size > cimbar::Config::image_size())
 		_offset = (size - cimbar::Config::image_size()) / 2;
diff --git a/src/lib/cimb_translator/Config.cpp b/src/lib/cimb_translator/Config.cpp
index 9e21a47..3b3e2de 100644
--- a/src/lib/cimb_translator/Config.cpp
+++ b/src/lib/cimb_translator/Config.cpp
@@ -1,94 +1,38 @@
 /* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
 #include "Config.h"
+#include <cmath>
 
 namespace cimbar {
 
-bool Config::dark()
+unsigned Config::total_cells()
 {
-	return true;
+	return std::pow(cells_per_col(), 2) - std::pow(corner_padding(), 2) * 4;
 }
 
-unsigned Config::color_bits()
+unsigned Config::decode_window_bits()
 {
-	return 2;
+	return std::pow(cell_size() + 2, 2);
 }
 
-unsigned Config::symbol_bits()
+unsigned Config::capacity(unsigned bitspercell)
 {
-	return 4;
-}
-
-unsigned Config::bits_per_cell()
-{
-	return color_bits() + symbol_bits();
-}
-
-unsigned Config::ecc_bytes()
-{
-	return 30;
-}
-
-int Config::image_size()
-{
-	return 1024;
-}
-
-unsigned Config::anchor_size()
-{
-	return 30;
-}
-
-unsigned Config::cell_size()
-{
-	return 8;
-}
-
-unsigned Config::cell_spacing()
-{
-	return cell_size() + 1;
-}
-
-unsigned Config::num_cells()
-{
-	return 112;
+	if (!bitspercell)
+		bitspercell = bits_per_cell();
+	return total_cells() * bitspercell / 8;
 }
 
 unsigned Config::corner_padding()
 {
-	return 6;
-}
-
-unsigned Config::interleave_blocks()
-{
-	return 155;
-}
-
-unsigned Config::interleave_partitions()
-{
-	return 2;
+	return lrint(54.0 / cell_spacing());
 }
 
 unsigned Config::fountain_chunk_size(unsigned ecc, unsigned bitspercell)
 {
-	// this calculation is based off the 112x112-6 grid.
-	// in that grid, we have 155 * bits_per_cell * 10 total bytes of data.
-	// so this neatly splits into 10 chunks per frame.
-	// ex: 690=6900/10 for ecc=40.
-	if (!bitspercell)
-		bitspercell = bits_per_cell();
-
+	// TODO: sanity checks?
+	// this should neatly split into fountain_chunks_per_frame() [ex: 10] chunks per frame.
 	// the other reasonable settings for fountain_chunks_per_frame are `2` and `5`
-	return (155-ecc) * bitspercell * 10 / fountain_chunks_per_frame();
-}
-
-unsigned Config::fountain_chunks_per_frame()
-{
-	return 10;
-}
-
-unsigned Config::compression_level()
-{
-	return 6;
+	const unsigned eccBlockSize = ecc_block_size();
+	return capacity(bitspercell) * (eccBlockSize-ecc) / eccBlockSize / fountain_chunks_per_frame();
 }
 
 }
diff --git a/src/lib/cimb_translator/Config.h b/src/lib/cimb_translator/Config.h
index b89456e..183dc5d 100644
--- a/src/lib/cimb_translator/Config.h
+++ b/src/lib/cimb_translator/Config.h
@@ -1,30 +1,105 @@
 /* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
 #pragma once
 
-// probably defaults with a pimpl to read/cache if there's a (yaml?) config locally?
+#include "GridConf.h"
+
 namespace cimbar
 {
-	namespace Config
+	class Config
 	{
-		bool dark();
-
-		unsigned color_bits();
-		unsigned symbol_bits();
-		unsigned bits_per_cell();
-		unsigned ecc_bytes();
-
-		int image_size();
-		unsigned anchor_size();
-
-		unsigned cell_size();
-		unsigned cell_spacing();
-		unsigned num_cells();
-		unsigned corner_padding();
-		unsigned interleave_blocks();
-		unsigned interleave_partitions();
-
-		unsigned fountain_chunk_size(unsigned ecc, unsigned bitspercell=0);
-		unsigned fountain_chunks_per_frame();
-		unsigned compression_level();
-	}
+	protected:
+		using GridConf = Conf8x8;
+
+	public:
+		static constexpr bool dark()
+		{
+			return true;
+		}
+
+		static constexpr unsigned color_bits()
+		{
+			return GridConf::color_bits;
+		}
+
+		static constexpr unsigned symbol_bits()
+		{
+			return GridConf::symbol_bits;
+		}
+
+		static constexpr unsigned bits_per_cell()
+		{
+			return color_bits() + symbol_bits();
+		}
+
+		static constexpr unsigned ecc_bytes()
+		{
+			return GridConf::ecc_bytes;
+		}
+
+		static constexpr unsigned ecc_block_size()
+		{
+			return GridConf::ecc_block_size;
+		}
+
+		static constexpr int image_size()
+		{
+			return GridConf::image_size;
+		}
+
+		static constexpr unsigned anchor_size()
+		{
+			return 30;
+		}
+
+		static constexpr unsigned cell_size()
+		{
+			return GridConf::cell_size;
+		}
+
+		static constexpr unsigned cell_spacing()
+		{
+			return cell_size() + 1;
+		}
+
+		static unsigned corner_padding();
+
+		static constexpr unsigned cell_offset()
+		{
+			return GridConf::cell_offset;
+		}
+
+		static constexpr unsigned cells_per_col()
+		{
+			return GridConf::cells_per_col;
+		}
+
+		static unsigned total_cells();
+
+		static unsigned decode_window_bits();
+
+		static unsigned capacity(unsigned bitspercell=0);
+
+		static constexpr unsigned interleave_blocks()
+		{
+			return ecc_block_size();
+		}
+
+		static constexpr unsigned interleave_partitions()
+		{
+			return 2;
+		}
+
+		static constexpr unsigned fountain_chunks_per_frame()
+		{
+			return 10;
+		}
+
+		static unsigned fountain_chunk_size(unsigned ecc, unsigned bitspercell=0);
+
+		static constexpr unsigned compression_level()
+		{
+			return 6;
+		}
+	};
 }
+
diff --git a/src/lib/cimb_translator/FloodDecodePositions.cpp b/src/lib/cimb_translator/FloodDecodePositions.cpp
index a0c61e3..4fc1e00 100644
--- a/src/lib/cimb_translator/FloodDecodePositions.cpp
+++ b/src/lib/cimb_translator/FloodDecodePositions.cpp
@@ -1,9 +1,10 @@
 /* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
 #include "FloodDecodePositions.h"
+#include <iostream>
 
 FloodDecodePositions::FloodDecodePositions(int spacing, int dimensions, int offset, int marker_size)
-    : _positions(CellPositions::compute(spacing, dimensions, offset, marker_size, 0))
-    , _cellFinder(_positions, dimensions, marker_size)
+	: _positions(CellPositions::compute(spacing, dimensions, offset, marker_size, 0))
+	, _cellFinder(_positions, dimensions, marker_size)
 {
 	reset();
 }
@@ -21,16 +22,23 @@ void FloodDecodePositions::reset()
 	for (unsigned i = 0; i < _positions.size(); ++i)
 	{
 		_remaining.push_back(true);
-		_instructions.push_back({CellDrift(), 0xFF});
+		_instructions.push_back({CellDrift(), 0xFE, 0xFE});
 	}
 
 	// seed
-	uint16_t smallRowLen = _cellFinder.dimensions() - (2*_cellFinder.marker_size()) - 1;
+	uint16_t smallRowLen = _cellFinder.dimensions() - (2*_cellFinder.marker_size());
 	uint16_t lastElem = _positions.size()-1;
 	_heap.push({0, 0});
-	_heap.push({smallRowLen, 0});
+	_heap.push({smallRowLen-1, 0});
 	_heap.push({lastElem, 0});
-	_heap.push({lastElem-smallRowLen, 0});
+	_heap.push({lastElem-(smallRowLen-1), 0});
+
+	// add more seed corners?
+	uint16_t betweenMarkerBlock = smallRowLen * _cellFinder.marker_size();
+	_heap.push({betweenMarkerBlock, 1});
+	_heap.push({betweenMarkerBlock+_cellFinder.dimensions()-1, 1});
+	_heap.push({lastElem-betweenMarkerBlock, 1});
+	_heap.push({lastElem-(betweenMarkerBlock+_cellFinder.dimensions()-1), 1});
 }
 
 bool FloodDecodePositions::done() const
@@ -47,30 +55,81 @@ FloodDecodePositions::iter FloodDecodePositions::next()
 
 		std::vector<bool>::reference needsDecode = _remaining[i];
 		if (!needsDecode)
-		    continue;
+			continue;
 
 		needsDecode = false;
 		++_count;
-		auto [drift, __] = _instructions[i];
-		return {i, _positions[i], drift};
+		auto [drift, __, cooldown] = _instructions[i];
+		return {i, _positions[i], drift, cooldown};
 	}
 
-	return {0, {0, 0}, CellDrift()};
+	return {0, {0, 0}, CellDrift(), 0xFF};
 }
 
-int FloodDecodePositions::update(unsigned index, const CellDrift& drift, unsigned error_distance)
+int FloodDecodePositions::update_adjacents(const std::array<int,4>& adj, const CellDrift& drift, unsigned error_distance, uint8_t cooldown)
 {
-	std::array<int,4> adj = _cellFinder.find(index);
 	for (int next : adj)
 	{
 		if (next < 0 or !_remaining[next])
 			continue;
 		decode_instructions& di = _instructions[next];
-		if (di.second <= error_distance)
+		if (std::get<1>(di) <= error_distance)
 			continue;
-		di = {drift, error_distance};
+		di = {drift, error_distance, cooldown};
 		_heap.push({next, error_distance});
 	}
+
+	return 0;
+}
+
+int FloodDecodePositions::update(unsigned index, const CellDrift& drift, unsigned error_distance, uint8_t cooldown)
+{
+	std::array<int,4> adj = _cellFinder.find(index);
+	update_adjacents(adj, drift, error_distance, cooldown);
+
+	auto& [_, prev_error, prev_cooldown] = _instructions[index];
+	// in the case where we have consecutive high confidence cells with no drift changes,
+	// it's safe(ish) to aggressively queue a few more cells
+	if (prev_error < 3 and error_distance < 3 and prev_cooldown == 4 and cooldown == 4)
+	{
+		unsigned rr = 0;
+		unsigned ll = 1;
+		unsigned dd = 2;
+		unsigned uu = 3;
+
+		int rridx = adj[rr];
+		int llidx = adj[ll];
+		if (rridx >= 0 and llidx >= 0)
+		{
+			std::array<int,4> horizon = {-1, -1, -1, -1};
+			horizon[0] = _cellFinder.right(rridx);
+			if (horizon[0])
+				horizon[1] = _cellFinder.right(horizon[0]);
+			horizon[2] = _cellFinder.left(llidx);
+			if (horizon[2])
+				horizon[3] = _cellFinder.left(horizon[2]);
+
+			update_adjacents(horizon, drift, error_distance, cooldown);
+		}
+
+		int uuidx = adj[uu];
+		int ddidx = adj[dd];
+		if (uuidx >= 0 and ddidx >= 0)
+		{
+			std::array<int,4> vert = {-1, -1, -1, -1};
+			vert[0] = _cellFinder.top(uuidx);
+			if (vert[0])
+				vert[1] = _cellFinder.top(vert[0]);
+			vert[2] = _cellFinder.bottom(ddidx);
+			if (vert[2])
+				vert[3] = _cellFinder.bottom(vert[2]);
+
+			update_adjacents(vert, drift, error_distance, cooldown);
+		}
+	}
+
+	prev_error = error_distance;
+	prev_cooldown = cooldown;
 	return 0;
 }
 
diff --git a/src/lib/cimb_translator/FloodDecodePositions.h b/src/lib/cimb_translator/FloodDecodePositions.h
index 44b608a..e421be6 100644
--- a/src/lib/cimb_translator/FloodDecodePositions.h
+++ b/src/lib/cimb_translator/FloodDecodePositions.h
@@ -12,8 +12,10 @@
 class FloodDecodePositions
 {
 public:
-	using iter = std::tuple<unsigned, CellPositions::coordinate, CellDrift>;
-	using decode_instructions = std::pair<CellDrift, uint8_t>; // drift, best_prio
+	using iter = std::tuple<unsigned, CellPositions::coordinate, CellDrift, uint8_t>;
+	// compress these types down to reduce size and cache pressure?
+	// i.e. with a struct ...
+	using decode_instructions = std::tuple<CellDrift, uint8_t, uint8_t>; // drift, best_prio, cooldown_pos
 	using decode_prio = std::tuple<uint16_t, uint8_t>; // index, prio
 
 	class PrioCompare
@@ -33,7 +35,10 @@ class FloodDecodePositions
 
 	bool done() const;
 	iter next();
-	int update(unsigned index, const CellDrift& drift, unsigned error_distance);
+	int update(unsigned index, const CellDrift& drift, unsigned error_distance, uint8_t cooldown);
+
+protected:
+	int update_adjacents(const std::array<int,4>& adj, const CellDrift& drift, unsigned error_distance, uint8_t cooldown);
 
 protected:
 	unsigned _index;
diff --git a/src/lib/cimb_translator/GridConf.h b/src/lib/cimb_translator/GridConf.h
new file mode 100644
index 0000000..60b77c4
--- /dev/null
+++ b/src/lib/cimb_translator/GridConf.h
@@ -0,0 +1,31 @@
+/* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
+#pragma once
+
+namespace cimbar
+{
+	struct Conf5x5
+	{
+		static constexpr unsigned color_bits = 2;
+		static constexpr unsigned symbol_bits = 2;
+		static constexpr unsigned ecc_bytes = 40;
+		static constexpr unsigned ecc_block_size = 216;
+		static constexpr int image_size = 988;
+
+		static constexpr unsigned cell_size = 5;
+		static constexpr unsigned cell_offset = 9;
+		static constexpr unsigned cells_per_col = 162;
+	};
+
+	struct Conf8x8
+	{
+		static constexpr unsigned color_bits = 2;
+		static constexpr unsigned symbol_bits = 4;
+		static constexpr unsigned ecc_bytes = 30;
+		static constexpr unsigned ecc_block_size = 155;
+		static constexpr int image_size = 1024;
+
+		static constexpr unsigned cell_size = 8;
+		static constexpr unsigned cell_offset = 8;
+		static constexpr unsigned cells_per_col = 112;
+	};
+}
diff --git a/src/lib/cimb_translator/bitmaps.h b/src/lib/cimb_translator/bitmaps.h
index 6261a01..741a1bf 100644
--- a/src/lib/cimb_translator/bitmaps.h
+++ b/src/lib/cimb_translator/bitmaps.h
@@ -1,6 +1,9 @@
-/* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
 namespace cimbar {
 static const std::map<std::string, std::string> bitmaps = {
+{"bitmap/2/00.png", R"(vuk:eJs4+BAAN/-MCG4DAADHAABtZLYAAANJTkaoAA6y#TzjGFAA$FDAqCsCco~EbAAA'yCG@v_CLK;IA'B'1'1(-o5}s%9~(gEzXCg/0(KC{QC'0;XE/9/#iBAAC'nHpwZ9)'&F)"},
+{"bitmap/2/01.png", R"(vuk:eJs4+BAAN/-MCG4DAADHAABtZLYAAANJTkaoAA6y#TzjGFAA$FDAqCsCco~EbAAAPzCG@v_CLK;IA'B'tWPcq1,(KC{Qw2t/_(Tj'hDTV)kAJ1[Mk)_SvlLAAAdZJzDwHP_Q%)"},
+{"bitmap/2/02.png", R"(vuk:eJs4+BAAN/-MCG4DAADHAABtZLYAAANJTkaoAA6y#TzjGFAA$FDAqCsCco~EbAAAvzCG@v_CLK;IA'B'1'1(YEGRxt(a[hFBQ/_(sI$~Ybu+SAY4$`FBn``[CAAAXLhYKMe8#(\C)"},
+{"bitmap/2/03.png", R"(vuk:eJs4+BAAN/-MCG4DAADHAABtZLYAAANJTkaoAA6y#TzjGFAA$FDAqCsCco~EbAAAfzCG@v_CY^So5JAAU)ai%|tW(8Xj^zH9_t(C$1XUh'(C~tC[}hv2Q?=BAAAAr7vbMo\F9BB)"},
 {"bitmap/4/00.png", R"(vuk:eJs4+BAAN/-MCG4DAAXLAAAA7FMAAA_)z_ZMAAdZ=J.!wCC'\vBAVBWBP%tvNAAA&aCw`XaxEylEB'B'atItc|3|y|UAp!E8e+_GyD?^VR_3wcW'Qh#GAaztVEMA`*8DBfF/k8AAAA9ZNoBz[uhNI)"},
 {"bitmap/4/01.png", R"(vuk:eJs4+BAAN/-MCG4DAAXLAAAA7FMAAA_)z_ZMAAdZ=J.!wCC'\vBAVBWBP%tvNAAA]aCw`Xax=HOU:EBtV)%tL-IV&7RD,W?p/]fZO-8B$}Fhjf%GC}~Y8(/Y$w|t^oN/ZNiN0s}\5AAAuW&wUY6eit&F)"},
 {"bitmap/4/02.png", R"(vuk:eJs4+BAAN/-MCG4DAAXLAAAA7FMAAA_)z_ZMAAdZ=J.!wCC'\vBAVBWBP%tvNAAA]aCw`Xax4{NUBFBt&t%tk`B'H{1N6k{N,,B$ho#%7F'Su&HLs]iDkfwcgZSGR501W0WE+WxodAAAuW&wUY6eit&F)"},
diff --git a/src/lib/cimb_translator/test/CimbDecoderTest.cpp b/src/lib/cimb_translator/test/CimbDecoderTest.cpp
index 05fe63e..59ce9fb 100644
--- a/src/lib/cimb_translator/test/CimbDecoderTest.cpp
+++ b/src/lib/cimb_translator/test/CimbDecoderTest.cpp
@@ -4,6 +4,8 @@
 
 #include "CimbDecoder.h"
 
+#include "bit_file/bitbuffer.h"
+#include "bit_file/bitmatrix.h"
 #include "cimb_translator/Common.h"
 #include "serialize/format.h"
 #include <opencv2/opencv.hpp>
@@ -46,11 +48,7 @@ TEST_CASE( "CimbDecoderTest/testSimpleDecode", "[unit]" )
 
 TEST_CASE( "CimbDecoderTest/testPrethresholdDecode", "[unit]" )
 {
-	// in practice, it can be useful to decode preprocessed symbol tiles
-	// the "0xFF" flag is passed to the average_hash function, which uses it to
-	// (1) skip computing the mean cell (threshold) value
-	// (2) compute the hash faster (exploiting that it's all 0s or all 1s)
-	// But in this test, we just want to see it get the right answer.
+	// validate the bitmatrix version acts as we expect
 	CimbDecoder cd(4, 0, true, 0xFF);
 
 	for (unsigned i = 0; i < 16; ++i)
@@ -63,9 +61,13 @@ TEST_CASE( "CimbDecoderTest/testPrethresholdDecode", "[unit]" )
 		cv::cvtColor(tenxten, tenxten, cv::COLOR_RGB2GRAY);
 		cv::adaptiveThreshold(tenxten, tenxten, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 9, 0);
 
+		bitbuffer bb((100/8) + 1);
+		bitmatrix::mat_to_bitbuffer(tenxten, bb.get_writer());
+		bitmatrix bm(bb, 10, 10);
+
 		unsigned drift_offset;
 		unsigned distance;
-		unsigned res = cd.decode_symbol(tenxten, drift_offset, distance);
+		unsigned res = cd.decode_symbol(bm, drift_offset, distance);
 		assertEquals(i, res);
 		assertEquals(4, drift_offset);
 		assertEquals(0, distance);
diff --git a/src/lib/cimb_translator/test/CimbReaderTest.cpp b/src/lib/cimb_translator/test/CimbReaderTest.cpp
index 5900888..6b6723f 100644
--- a/src/lib/cimb_translator/test/CimbReaderTest.cpp
+++ b/src/lib/cimb_translator/test/CimbReaderTest.cpp
@@ -73,9 +73,9 @@ TEST_CASE( "CimbReaderTest/testSample", "[unit]" )
 		++count;
 	}
 
-	string expected = "0=0 99=8 12097=9 12100=0 12196=1 12197=25 12198=33 12200=5 12201=0 12295=32 "
-	        "12296=32 12297=46 12298=32 12299=34 12300=30 12301=32 12394=32 12395=57 "
-	        "12396=37 12397=38 12398=10 12399=15";
+	string expected = "0=0 99=8 600=33 710=28 711=30 821=8 822=22 823=19 934=55 11688=55 11799=25 "
+			"11900=28 12000=23 12100=0 12200=5 12201=0 12298=32 12299=34 12300=30 12301=32 "
+			"12398=10 12399=15";
 	assertEquals( expected, turbo::str::join(res) );
 
 	PositionData pos;
@@ -109,8 +109,8 @@ TEST_CASE( "CimbReaderTest/testSampleMessy", "[unit]" )
 		++count;
 	}
 
-	string expected = "0=0 1=28 99=8 11900=28 12000=23 12001=29 12100=0 12101=0 12102=25 12200=5 "
-	        "12201=0 12202=33 12297=46 12298=32 12299=34 12300=30 12301=32 12302=32 12396=37 12397=38 12398=10 12399=15";
+	string expected = "0=0 99=8 600=33 711=30 11462=2 11573=33 11574=0 11685=52 11686=17 11687=41 "
+			"11688=55 11797=30 11798=15 11799=25 12200=5 12298=46 12299=34 12300=30 12301=32 12397=38 12398=10 12399=15";
 	assertEquals( expected, turbo::str::join(res) );
 
 	PositionData pos;
@@ -149,10 +149,10 @@ TEST_CASE( "CimbReaderTest/testCCM", "[unit]" )
 	std::stringstream ss;
 	ss << decoder._ccm.mat();
 	assertEquals("[1.5489368, 0.050406694, -0.016417533;\n"
-	             " 0.0055368096, 1.5302141, -0.0011175937;\n"
-	             " 0, 0, 1.4676259]", ss.str());
+				 " 0.0055368096, 1.5302141, -0.0011175937;\n"
+				 " 0, 0, 1.4676259]", ss.str());
 
-	std::array<unsigned, 6> expectedColors = {0, 0, 1, 0, 2, 0};
+	std::array<unsigned, 6> expectedColors = {0, 0, 0, 1, 1, 3};
 	for (unsigned i = 0; i < expectedColors.size(); ++i)
 	{
 		PositionData pos;
@@ -173,7 +173,7 @@ TEST_CASE( "CimbReaderTest/testCCM.Disabled", "[unit]" )
 
 	assertFalse( decoder._ccm.active() );
 
-	std::array<unsigned, 6> expectedColors = {0, 0, 1, 0, 2, 0};
+	std::array<unsigned, 6> expectedColors = {0, 0, 0, 1, 1, 3};
 	for (unsigned i = 0; i < expectedColors.size(); ++i)
 	{
 		PositionData pos;
@@ -197,10 +197,10 @@ TEST_CASE( "CimbReaderTest/testCCM.VeryNecessary", "[unit]" )
 	std::stringstream ss;
 	ss << decoder._ccm.mat();
 	assertEquals("[1.0675567, 0.21678841, -0.013292357;\n"
-	             " 0.023812667, 0.98703396, -0.0048082001;\n"
-	             " 0, 0, 1.0017186]", ss.str());
+				 " 0.023812667, 0.98703396, -0.0048082001;\n"
+				 " 0, 0, 1.0017186]", ss.str());
 
-	std::array<unsigned, 6> expectedColors = {0, 0, 0, 0, 2, 2}; // it's wrong, but it's consistent!
+	std::array<unsigned, 6> expectedColors = {0, 0, 0, 0, 0, 3}; // it's wrong, but it's consistent!
 	for (unsigned i = 0; i < expectedColors.size(); ++i)
 	{
 		PositionData pos;
diff --git a/src/lib/cimb_translator/test/FloodDecodePositionsTest.cpp b/src/lib/cimb_translator/test/FloodDecodePositionsTest.cpp
index f0febb7..6d38931 100644
--- a/src/lib/cimb_translator/test/FloodDecodePositionsTest.cpp
+++ b/src/lib/cimb_translator/test/FloodDecodePositionsTest.cpp
@@ -23,13 +23,14 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 	unsigned i;
 	CellPositions::coordinate xy;
 	CellDrift drift;
+	uint8_t cooldown;
 
 	// validate seed points
 	unsigned count = 0;
-	for (int c = 0; c < 4; ++c)
+	for (int c = 0; c < 8; ++c)
 	{
 		// 0
-		std::tie(i, xy, drift) = cells.next();
+		std::tie(i, xy, drift, cooldown) = cells.next();
 		assertEquals(0, drift.x());
 		assertEquals(0, drift.y());
 
@@ -38,25 +39,49 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 			assertEquals(62, xy.first);
 			assertEquals(8, xy.second);
 			drift.updateDrift(1, 1);
-			cells.update(i, drift, 1);
+			cells.update(i, drift, 1, cooldown);
 		}
 		else if (i == 99)
 		{
 			assertEquals(953, xy.first);
 			assertEquals(8, xy.second);
-			cells.update(i, drift, 2);
+			cells.update(i, drift, 2, cooldown);
 		}
 		else if (i == 12300)
 		{
 			assertEquals(62, xy.first);
 			assertEquals(1007, xy.second);
-			cells.update(i, drift, 2);
+			cells.update(i, drift, 2, cooldown);
 		}
 		else if (i == 12399)
 		{
 			assertEquals(953, xy.first);
 			assertEquals(1007, xy.second);
-			cells.update(i, drift, 2);
+			cells.update(i, drift, 2, cooldown);
+		}
+		else if (i == 600)
+		{
+			assertEquals(8, xy.first);
+			assertEquals(62, xy.second);
+			cells.update(i, drift, 2, cooldown);
+		}
+		else if (i == 711)
+		{
+			assertEquals(1007, xy.first);
+			assertEquals(62, xy.second);
+			cells.update(i, drift, 2, cooldown);
+		}
+		else if (i == 11688)
+		{
+			assertEquals(8, xy.first);
+			assertEquals(953, xy.second);
+			cells.update(i, drift, 2, cooldown);
+		}
+		else if (i == 11799)
+		{
+			assertEquals(1007, xy.first);
+			assertEquals(953, xy.second);
+			cells.update(i, drift, 2, cooldown);
 		}
 		else
 			FAIL("i ?= " << i);
@@ -68,7 +93,7 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 	// we did "update(..., 1) for index=1. So the next cells should be the ones adjacent to 0: 1, 100.
 	for (int c = 0; c < 2; ++c)
 	{
-		std::tie(i, xy, drift) = cells.next();
+		std::tie(i, xy, drift, cooldown) = cells.next();
 		if (i == 1)
 		{
 			assertEquals(71, xy.first);
@@ -82,10 +107,11 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 		else
 			FAIL("i ?= " << i);
 
+		// we manually set drift to 1,1 -- it should be persisted
 		assertEquals(1, drift.x());
 		assertEquals(1, drift.y());
 
-		cells.update(i, drift, 3);
+		cells.update(i, drift, 3, cooldown);
 		remainingPos.erase(i);
 		++count;
 	}
@@ -93,8 +119,8 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 	// as for the rest... we'll just make sure we hit them all
 	while (!cells.done())
 	{
-		std::tie(i, xy, drift) = cells.next();
-		cells.update(i, drift, 1);
+		std::tie(i, xy, drift, cooldown) = cells.next();
+		cells.update(i, drift, 1, cooldown);
 		remainingPos.erase(i);
 		++count;
 	}
diff --git a/src/lib/cimbar_js/CMakeLists.txt b/src/lib/cimbar_js/CMakeLists.txt
index 2358892..eced8e6 100644
--- a/src/lib/cimbar_js/CMakeLists.txt
+++ b/src/lib/cimbar_js/CMakeLists.txt
@@ -48,7 +48,7 @@ set (LINK_WASM_LIST
 	-s USE_GLFW=3
 	-s FILESYSTEM=0
 	-s TOTAL_MEMORY=134217728
-	-s EXPORTED_FUNCTIONS='["_render","_next_frame","_initialize_GL","_encode","_configure"]'
+	-s EXPORTED_FUNCTIONS='["_render","_next_frame","_initialize_GL","_encode","_configure","_malloc","_free"]'
 )
 string(REPLACE ";" " " LINK_WASM_FLAGS "${LINK_WASM_LIST}")
 
diff --git a/src/lib/cimbar_js/cimbar_js.cpp b/src/lib/cimbar_js/cimbar_js.cpp
index ce6fa76..cfb69d1 100644
--- a/src/lib/cimbar_js/cimbar_js.cpp
+++ b/src/lib/cimbar_js/cimbar_js.cpp
@@ -1,6 +1,7 @@
 /* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
 #include "cimbar_js.h"
 
+#include "cimb_translator/Config.h"
 #include "encoder/SimpleEncoder.h"
 #include "gui/window_glfw.h"
 #include "util/byte_istream.h"
@@ -18,9 +19,9 @@ namespace {
 	uint8_t _encodeId = 0;
 
 	// settings
-	unsigned _ecc = 30;
-	unsigned _colorBits = 2;
-	int _compressionLevel = 6;
+	unsigned _ecc = cimbar::Config::ecc_bytes();
+	unsigned _colorBits = cimbar::Config::color_bits();
+	int _compressionLevel = cimbar::Config::compression_level();
 }
 
 extern "C" {
@@ -30,6 +31,11 @@ int initialize_GL(int width, int height)
 	if (_window)
 		return 1;
 
+	// must be divisible by 4???
+	if (width % 4 != 0)
+		width += (4 - width % 4);
+	if (height % 4 != 0)
+		height += (4 - height % 4);
 	std::cerr << "initializing " << width << " by " << height << " window";
 
 	_window = std::make_shared<cimbar::window_glfw>(width, height, "Cimbar Encoder");
@@ -105,11 +111,11 @@ int configure(unsigned color_bits, unsigned ecc, int compression)
 {
 	// defaults
 	if (color_bits > 3)
-		color_bits = 2;
+		color_bits = cimbar::Config::color_bits();
 	if (ecc < 0 or ecc >= 150)
-		ecc = 30;
+		ecc = cimbar::Config::ecc_bytes();
 	if (compression < 0 or compression > 22)
-		compression = 6;
+		compression = cimbar::Config::compression_level();
 
 	// check if we need to refresh the stream
 	bool refresh = (color_bits != _colorBits or ecc != _ecc or compression != _compressionLevel);
diff --git a/src/lib/encoder/Decoder.h b/src/lib/encoder/Decoder.h
index 3a484b1..49dc6a2 100644
--- a/src/lib/encoder/Decoder.h
+++ b/src/lib/encoder/Decoder.h
@@ -30,6 +30,7 @@ class Decoder
 
 protected:
 	unsigned _eccBytes;
+	unsigned _eccBlockSize;
 	unsigned _colorBits;
 	unsigned _bitsPerOp;
 	unsigned _interleaveBlocks;
@@ -38,12 +39,13 @@ class Decoder
 };
 
 inline Decoder::Decoder(int ecc_bytes, int color_bits, bool interleave)
-    : _eccBytes(ecc_bytes >= 0? ecc_bytes : cimbar::Config::ecc_bytes())
-    , _colorBits(color_bits >= 0? color_bits : cimbar::Config::color_bits())
-    , _bitsPerOp(cimbar::Config::symbol_bits() + _colorBits)
-    , _interleaveBlocks(interleave? cimbar::Config::interleave_blocks() : 0)
-    , _interleavePartitions(cimbar::Config::interleave_partitions())
-    , _decoder(cimbar::Config::symbol_bits(), _colorBits, cimbar::Config::dark(), 0xFF)
+	: _eccBytes(ecc_bytes >= 0? ecc_bytes : cimbar::Config::ecc_bytes())
+	, _eccBlockSize(cimbar::Config::ecc_block_size())
+	, _colorBits(color_bits >= 0? color_bits : cimbar::Config::color_bits())
+	, _bitsPerOp(cimbar::Config::symbol_bits() + _colorBits)
+	, _interleaveBlocks(interleave? cimbar::Config::interleave_blocks() : 0)
+	, _interleavePartitions(cimbar::Config::interleave_partitions())
+	, _decoder(cimbar::Config::symbol_bits(), _colorBits, cimbar::Config::dark(), 0xFF)
 {
 }
 
@@ -62,9 +64,10 @@ inline Decoder::Decoder(int ecc_bytes, int color_bits, bool interleave)
 template <typename STREAM>
 inline unsigned Decoder::do_decode(CimbReader& reader, STREAM& ostream)
 {
-	bitbuffer bb(_bitsPerOp * 1550);
+	bitbuffer bb(cimbar::Config::capacity(_bitsPerOp));
 	std::vector<unsigned> interleaveLookup = Interleave::interleave_reverse(reader.num_reads(), _interleaveBlocks, _interleavePartitions);
-	std::array<PositionData, 12400> colorPositions; // 12400 = 1500 * 8, aka the number of cells. This should probably be determined at runtime
+	std::vector<PositionData> colorPositions;
+	colorPositions.resize(reader.num_reads()); // the number of cells == reader.num_reads(). Can we calculate this from config at compile time?
 
 	// read symbols first
 	while (!reader.done())
@@ -88,7 +91,7 @@ inline unsigned Decoder::do_decode(CimbReader& reader, STREAM& ostream)
 		bb.write(bits, p.i, _colorBits);
 	}
 
-	reed_solomon_stream rss(ostream, _eccBytes);
+	reed_solomon_stream rss(ostream, _eccBytes, _eccBlockSize);
 	return bb.flush(rss);
 }
 
diff --git a/src/lib/encoder/SimpleEncoder.h b/src/lib/encoder/SimpleEncoder.h
index 2139c8c..b21c4cc 100644
--- a/src/lib/encoder/SimpleEncoder.h
+++ b/src/lib/encoder/SimpleEncoder.h
@@ -26,6 +26,7 @@ class SimpleEncoder
 
 protected:
 	unsigned _eccBytes;
+	unsigned _eccBlockSize;
 	unsigned _bitsPerSymbol;
 	unsigned _bitsPerColor;
 	bool _dark;
@@ -33,10 +34,11 @@ class SimpleEncoder
 };
 
 inline SimpleEncoder::SimpleEncoder(int ecc_bytes, unsigned bits_per_symbol, int bits_per_color)
-    : _eccBytes(ecc_bytes >= 0? ecc_bytes : cimbar::Config::ecc_bytes())
-    , _bitsPerSymbol(bits_per_symbol? bits_per_symbol : cimbar::Config::symbol_bits())
-    , _bitsPerColor(bits_per_color >= 0? bits_per_color : cimbar::Config::color_bits())
-    , _dark(cimbar::Config::dark())
+	: _eccBytes(ecc_bytes >= 0? ecc_bytes : cimbar::Config::ecc_bytes())
+	, _eccBlockSize(cimbar::Config::ecc_block_size())
+	, _bitsPerSymbol(bits_per_symbol? bits_per_symbol : cimbar::Config::symbol_bits())
+	, _bitsPerColor(bits_per_color >= 0? bits_per_color : cimbar::Config::color_bits())
+	, _dark(cimbar::Config::dark())
 {
 }
 
@@ -66,7 +68,7 @@ inline std::optional<cv::Mat> SimpleEncoder::encode_next(STREAM& stream, int can
 	unsigned bits_per_op = _bitsPerColor + _bitsPerSymbol;
 	CimbWriter writer(_bitsPerSymbol, _bitsPerColor, _dark, canvas_size);
 
-	reed_solomon_stream rss(stream, _eccBytes);
+	reed_solomon_stream rss(stream, _eccBytes, _eccBlockSize);
 	bitreader br;
 	while (rss.good())
 	{
diff --git a/src/lib/encoder/reed_solomon_stream.h b/src/lib/encoder/reed_solomon_stream.h
index ff3646a..2f883f0 100644
--- a/src/lib/encoder/reed_solomon_stream.h
+++ b/src/lib/encoder/reed_solomon_stream.h
@@ -11,13 +11,10 @@ template <typename STREAM>
 class reed_solomon_stream
 {
 public:
-	static const unsigned buffer_size = 155;
-
-public:
-	reed_solomon_stream(STREAM& stream, unsigned ecc)
-	    : _stream(stream)
-	    , _rs(ecc)
-	    , _good(stream.good())
+	reed_solomon_stream(STREAM& stream, unsigned ecc, unsigned buffer_size)
+		: _stream(stream)
+		, _rs(ecc)
+		, _good(stream.good())
 	{
 		_buffer.resize(buffer_size, 0);
 	}
@@ -32,10 +29,12 @@ class reed_solomon_stream
 		return _stream.tellp();
 	}
 
-	std::streamsize readsome(char* data=NULL, unsigned length=buffer_size)
+	std::streamsize readsome(char* data=NULL, unsigned length=0)
 	{
 		if (!data)
 			data = _buffer.data();
+		if (!length)
+			length = _buffer.size();
 
 		_stream.read(data, length - _rs.parity());
 		std::streamsize bytes = _stream.gcount();
@@ -49,7 +48,7 @@ class reed_solomon_stream
 
 		// else
 		_rs.encode(data, bytes, data);
-		return buffer_size;
+		return _buffer.size();
 	}
 
 	reed_solomon_stream& write(const char* data, unsigned length)
@@ -63,16 +62,16 @@ class reed_solomon_stream
 		}
 
 		// else
-		while (length >= buffer_size)
+		while (length >= _buffer.size())
 		{
-			ssize_t bytes = _rs.decode(data, buffer_size, _buffer.data());
+			ssize_t bytes = _rs.decode(data, _buffer.size(), _buffer.data());
 			if (bytes <= 0)
-				_stream << ReedSolomon::BadChunk(buffer_size - _rs.parity());
+				_stream << ReedSolomon::BadChunk(_buffer.size() - _rs.parity());
 			else
 				_stream.write(_buffer.data(), bytes);
 
-			length -= buffer_size;
-			data += buffer_size;
+			length -= _buffer.size();
+			data += _buffer.size();
 		}
 		return *this;
 	}
diff --git a/src/lib/encoder/test/DecoderTest.cpp b/src/lib/encoder/test/DecoderTest.cpp
index d88fd4c..16e2bfb 100644
--- a/src/lib/encoder/test/DecoderTest.cpp
+++ b/src/lib/encoder/test/DecoderTest.cpp
@@ -56,8 +56,6 @@ TEST_CASE( "DecoderTest/testDecode.Sample", "[unit]" )
 	unsigned bytesDecoded = dec.decode(TestCimbar::getSample("6bit/4_30_f0_627_extract.jpg"), decodedFile);
 	assertEquals( 9300, bytesDecoded );
 
-	if (CV_VERSION_MAJOR == 3)
-		assertEquals( "3de927c8aa0221807a2784210160cdc17567eb587bf01233d166900aadf14bf5", get_hash(decodedFile) );
-	else // # cv4
-		assertEquals( "59ddb2516b4ff5a528aebe538a22b736a6714263a454d20e146e1ffbba36c5ae", get_hash(decodedFile) );
+	if (CV_VERSION_MAJOR == 4)
+		assertEquals( "0f74a76cb1f59df7a42449a3527d464d913d12a03bffa51d6f53828724c3feb1", get_hash(decodedFile) );
 }
diff --git a/src/lib/encoder/test/reed_solomon_streamTest.cpp b/src/lib/encoder/test/reed_solomon_streamTest.cpp
index 3a19d7b..a270c95 100644
--- a/src/lib/encoder/test/reed_solomon_streamTest.cpp
+++ b/src/lib/encoder/test/reed_solomon_streamTest.cpp
@@ -14,11 +14,11 @@ namespace {
 	string exampleDecodedBlock()
 	{
 		string ex = "01234567890123456789012345678901234567890123456789012345678901234567890123456789"
-		        "012345678901234567890123456789012345678901234567890123456789";
+				"012345678901234567890123456789012345678901234567890123456789";
 		return ex;
 	}
 
-	string exampleEncodedBlock()
+	string exampleEncodedBlock155()
 	{
 		string ex = exampleDecodedBlock() + "\xa4t\x02\x03r\xc3\xad\xf2`\xc5\xb6\x9e&xs";
 		return ex;
@@ -33,18 +33,18 @@ TEST_CASE( "reed_solomon_streamTest/testEncodeOnce", "[unit]" )
 		input += "0123456789";
 
 	stringstream ins(input);
-	reed_solomon_stream<stringstream> rss(ins, 15);
+	reed_solomon_stream<stringstream> rss(ins, 15, 155);
 
 	assertEquals( 155, rss.readsome() );
-	assertEquals( exampleEncodedBlock(), string(rss.buffer(), 155) );
+	assertEquals( exampleEncodedBlock155(), string(rss.buffer(), 155) );
 }
 
 TEST_CASE( "reed_solomon_streamTest/testDecodeOnce", "[unit]" )
 {
 	stringstream outs;
-	reed_solomon_stream<stringstream> rss(outs, 15);
+	reed_solomon_stream<stringstream> rss(outs, 15, 155);
 
-	string encoded = exampleEncodedBlock();
+	string encoded = exampleEncodedBlock155();
 	rss.write(encoded.data(), encoded.size());
 
 	string actual = outs.str();
@@ -55,7 +55,7 @@ TEST_CASE( "reed_solomon_streamTest/testDecodeOnce", "[unit]" )
 TEST_CASE( "reed_solomon_streamTest/testDecodeBad", "[unit]" )
 {
 	stringstream outs;
-	reed_solomon_stream<stringstream> rss(outs, 15);
+	reed_solomon_stream<stringstream> rss(outs, 15, 155);
 
 	string encoded = string(155, 'f');
 	rss.write(encoded.data(), encoded.size());
diff --git a/src/lib/extractor/Deskewer.cpp b/src/lib/extractor/Deskewer.cpp
index 0fd3418..fff8f8b 100644
--- a/src/lib/extractor/Deskewer.cpp
+++ b/src/lib/extractor/Deskewer.cpp
@@ -1,17 +1,18 @@
 /* This code is subject to the terms of the Mozilla Public License, v.2.0. http://mozilla.org/MPL/2.0/. */
 #include "Deskewer.h"
+#include "cimb_translator/Config.h"
 
 #include <iostream>
 
-Deskewer::Deskewer(unsigned total_size, unsigned anchor_size)
-    : _totalSize(total_size)
-    , _anchorSize(anchor_size)
+Deskewer::Deskewer(unsigned image_size, unsigned anchor_size)
+	: _imageSize(image_size? image_size : cimbar::Config::image_size())
+	, _anchorSize(anchor_size? anchor_size : cimbar::Config::anchor_size())
 {
 }
 
-int Deskewer::total_size() const
+unsigned Deskewer::image_size() const
 {
-	return _totalSize;
+	return _imageSize;
 }
 
 cv::Mat Deskewer::deskew(std::string img, const Corners& corners)
diff --git a/src/lib/extractor/Deskewer.h b/src/lib/extractor/Deskewer.h
index 3758e37..4bf8d5b 100644
--- a/src/lib/extractor/Deskewer.h
+++ b/src/lib/extractor/Deskewer.h
@@ -11,8 +11,8 @@
 class Deskewer
 {
 public:
-	Deskewer(unsigned total_size=1024, unsigned anchor_size=30);
-	int total_size() const;
+	Deskewer(unsigned image_size=0, unsigned anchor_size=0);
+	unsigned image_size() const;
 
 	template <typename MAT>
 	MAT deskew(const MAT& img, const Corners& corners);
@@ -21,7 +21,7 @@ class Deskewer
 	bool save(const cv::Mat& img, std::string path);
 
 protected:
-	int _totalSize;
+	int _imageSize;
 	int _anchorSize;
 };
 
@@ -30,11 +30,11 @@ inline MAT Deskewer::deskew(const MAT& img, const Corners& corners)
 {
 	std::vector<cv::Point2f> outputPoints;
 	outputPoints.push_back(cv::Point2f(_anchorSize, _anchorSize));
-	outputPoints.push_back(cv::Point2f(_totalSize - _anchorSize, _anchorSize));
-	outputPoints.push_back(cv::Point2f(_anchorSize, _totalSize - _anchorSize));
-	outputPoints.push_back(cv::Point2f(_totalSize - _anchorSize, _totalSize - _anchorSize));
+	outputPoints.push_back(cv::Point2f(_imageSize - _anchorSize, _anchorSize));
+	outputPoints.push_back(cv::Point2f(_anchorSize, _imageSize - _anchorSize));
+	outputPoints.push_back(cv::Point2f(_imageSize - _anchorSize, _imageSize - _anchorSize));
 
-	MAT output(_totalSize, _totalSize, img.type());
+	MAT output(_imageSize, _imageSize, img.type());
 	cv::Mat transform = cv::getPerspectiveTransform(corners.all(), outputPoints);
 
 	cv::warpPerspective(img, output, transform, output.size(), cv::INTER_LINEAR);
diff --git a/src/lib/extractor/Extractor.cpp b/src/lib/extractor/Extractor.cpp
index 38fbc97..582811c 100644
--- a/src/lib/extractor/Extractor.cpp
+++ b/src/lib/extractor/Extractor.cpp
@@ -3,10 +3,13 @@
 
 #include "Deskewer.h"
 #include "Scanner.h"
+#include "cimb_translator/Config.h"
 #include <vector>
 using std::string;
 
-Extractor::Extractor()
+Extractor::Extractor(unsigned image_size, unsigned anchor_size)
+	: _imageSize(image_size? image_size : cimbar::Config::image_size())
+	, _anchorSize(anchor_size? anchor_size : cimbar::Config::anchor_size())
 {
 }
 
@@ -18,10 +21,10 @@ int Extractor::extract(const cv::Mat& img, cv::Mat& out)
 		return FAILURE;
 
 	Corners corners(points);
-	Deskewer de;
+	Deskewer de(_imageSize, _anchorSize);
 	out = de.deskew(img, corners);
 
-	if ( !corners.is_granular_scale(de.total_size()) )
+	if ( !corners.is_granular_scale(de.image_size()) )
 		return NEEDS_SHARPEN;
 	return SUCCESS;
 }
@@ -34,10 +37,10 @@ int Extractor::extract(const cv::UMat& img, cv::UMat& out)
 		return FAILURE;
 
 	Corners corners(points);
-	Deskewer de;
+	Deskewer de(_imageSize, _anchorSize);
 	out = de.deskew(img, corners);
 
-	if ( !corners.is_granular_scale(de.total_size()) )
+	if ( !corners.is_granular_scale(de.image_size()) )
 		return NEEDS_SHARPEN;
 	return SUCCESS;
 }
diff --git a/src/lib/extractor/Extractor.h b/src/lib/extractor/Extractor.h
index 3e8a649..9e376a8 100644
--- a/src/lib/extractor/Extractor.h
+++ b/src/lib/extractor/Extractor.h
@@ -12,7 +12,7 @@ class Extractor
 	static constexpr int NEEDS_SHARPEN = 2;
 
 public:
-	Extractor();
+	Extractor(unsigned image_size=0, unsigned anchor_size=0);
 
 	int extract(const cv::Mat& img, cv::Mat& out);
 	int extract(const cv::UMat& img, cv::UMat& out);
@@ -20,4 +20,6 @@ class Extractor
 	int extract(std::string read_path, std::string write_path);
 
 protected:
+	unsigned _imageSize;
+	unsigned _anchorSize;
 };
diff --git a/src/lib/extractor/test/DeskewerTest.cpp b/src/lib/extractor/test/DeskewerTest.cpp
index 0bdf70c..d5086f8 100644
--- a/src/lib/extractor/test/DeskewerTest.cpp
+++ b/src/lib/extractor/test/DeskewerTest.cpp
@@ -11,7 +11,7 @@
 TEST_CASE( "DeskewerTest/testSimple", "[unit]" )
 {
 	Corners corners({312, 519}, {323, 2586}, {2405, 461}, {2425, 2594});
-	Deskewer de;
+	Deskewer de(1024, 30);
 
 	cv::Mat actual = de.deskew(TestCimbar::getSample("6bit/4_30_f0_big.jpg"), corners);
 	assertEquals(cv::Size(1024, 1024), actual.size());
diff --git a/src/lib/extractor/test/ExtractorTest.cpp b/src/lib/extractor/test/ExtractorTest.cpp
index 2378e0e..0ea7a7d 100644
--- a/src/lib/extractor/test/ExtractorTest.cpp
+++ b/src/lib/extractor/test/ExtractorTest.cpp
@@ -14,7 +14,7 @@ TEST_CASE( "ExtractorTest/testExtract", "[unit]" )
 	MakeTempDirectory tempdir;
 
 	std::string imgPath = tempdir.path() / "ex.jpg";
-	Extractor ext;
+	Extractor ext(1024, 30);
 	ext.extract(TestCimbar::getSample("6bit/4_30_f0_big.jpg"), imgPath);
 
 	cv::Mat out = cv::imread(imgPath);
@@ -27,7 +27,7 @@ TEST_CASE( "ExtractorTest/testExtractMid", "[unit]" )
 	MakeTempDirectory tempdir;
 
 	std::string imgPath = tempdir.path() / "ex.jpg";
-	Extractor ext;
+	Extractor ext(1024, 30);
 	ext.extract(TestCimbar::getSample("6bit/4_30_f2_734.jpg"), imgPath);
 
 	cv::Mat out = cv::imread(imgPath);
@@ -40,7 +40,7 @@ TEST_CASE( "ExtractorTest/testExtractUpscale", "[unit]" )
 	MakeTempDirectory tempdir;
 
 	std::string imgPath = tempdir.path() / "exup.jpg";
-	Extractor ext;
+	Extractor ext(1024, 30);
 	ext.extract(TestCimbar::getSample("6bit/4_30_f0_627.jpg"), imgPath);
 
 	cv::Mat out = cv::imread(imgPath);
diff --git a/src/lib/extractor/test/UndistortTest.cpp b/src/lib/extractor/test/UndistortTest.cpp
index aa21fe4..23a3e3a 100644
--- a/src/lib/extractor/test/UndistortTest.cpp
+++ b/src/lib/extractor/test/UndistortTest.cpp
@@ -30,7 +30,7 @@ TEST_CASE( "UndistortTest/testUndistortAndExtract", "[unit]" )
 	Undistort<SimpleCameraCalibration> und;
 	assertTrue( und.undistort(img, out) );
 
-	Extractor ex;
+	Extractor ex(1024, 30);
 	assertTrue( ex.extract(out, out) );
 
 	assertEquals( 0x18f26faca7766794, image_hash::average_hash(out) );
diff --git a/src/lib/fountain/fountain_decoder_sink.h b/src/lib/fountain/fountain_decoder_sink.h
index 3fcb10d..118a65f 100644
--- a/src/lib/fountain/fountain_decoder_sink.h
+++ b/src/lib/fountain/fountain_decoder_sink.h
@@ -5,6 +5,7 @@
 #include "FountainMetadata.h"
 #include "serialize/format.h"
 
+#include <cstdio>
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -15,9 +16,10 @@ template <typename OUTSTREAM>
 class fountain_decoder_sink
 {
 public:
-	fountain_decoder_sink(std::string data_dir, unsigned chunk_size)
-	    : _dataDir(data_dir)
-	    , _chunkSize(chunk_size)
+	fountain_decoder_sink(std::string data_dir, unsigned chunk_size, bool log_writes=false)
+		: _dataDir(data_dir)
+		, _chunkSize(chunk_size)
+		, _logWrites(log_writes)
 	{
 	}
 
@@ -36,6 +38,8 @@ class fountain_decoder_sink
 		std::string file_path = fmt::format("{}/{}", _dataDir, get_filename(md));
 		OUTSTREAM f(file_path);
 		f.write((char*)data.data(), data.size());
+		if (_logWrites)
+			printf("%s\n", file_path.c_str());
 		return true;
 	}
 
@@ -143,4 +147,5 @@ class fountain_decoder_sink
 	std::unordered_map<uint8_t, fountain_decoder_stream> _streams;
 	// track the uint32_t combo of (encode_id,size) to avoid redundant work
 	std::set<uint32_t> _done;
+	bool _logWrites;
 };
diff --git a/src/lib/image_hash/ahash_result.h b/src/lib/image_hash/ahash_result.h
index 6a90cb4..8781a18 100644
--- a/src/lib/image_hash/ahash_result.h
+++ b/src/lib/image_hash/ahash_result.h
@@ -4,37 +4,40 @@
 #include "bit_extractor.h"
 #include "intx/intx.hpp"
 #include <array>
+#include <cmath>
 #include <iostream>
 #include <utility>
 
 namespace image_hash
 {
 
+template <unsigned CELLSIZE>
 class ahash_result
 {
 public:
 	static const int FAST = 5;
 	static const int ALL = 9;
+	static constexpr unsigned CELLAREA = (CELLSIZE+2)*(CELLSIZE+2);
 
 	// out from the center.
 	// 4 == center.
 	// 5, 7, 3, 1 == sides.
 	// 8, 0, 2, 6 == corners.
 	// mode=FAST will discard the corner checks.
-	static constexpr std::array<int, 9> _ORDER = {4, 5, 7, 3, 1, 8, 0, 2, 6};
+	static constexpr std::array<unsigned, 9> _ORDER = {4, 5, 7, 3, 1, 8, 0, 2, 6};
 
 public:
 	class iterator
 	{
 	public:
 		iterator(const ahash_result& hr, unsigned i=0)
-		    : _hr(hr)
-		    , _i(i)
+			: _hr(hr)
+			, _i(i)
 		{}
 
-		std::pair<int, uint64_t> operator*()
+		std::pair<unsigned, uint64_t> operator*()
 		{
-			int idx = _hr._ORDER[_i];
+			unsigned idx = _hr._ORDER[_i];
 			return {idx, _hr._results[idx]};
 		}
 
@@ -56,8 +59,8 @@ class ahash_result
 
 public:
 	ahash_result(const intx::uint128& bits, unsigned mode=ALL)
-	    : _bits(bits)
-	    , _mode(mode)
+		: _bits(bits)
+		, _mode(mode)
 	{
 		if (mode == ALL)
 			_results = extract_all();
@@ -67,38 +70,38 @@ class ahash_result
 
 	std::array<uint64_t, 9> extract_all() const
 	{
-		bit_extractor<intx::uint128, 100> be(_bits);
+		bit_extractor<intx::uint128, CELLAREA, CELLSIZE> be(_bits);
 		return {
 			// top row -- top left bit is the start bit (0). bottom right is end bit.
-			be.extract(0, 10, 20, 30, 40, 50, 60, 70), // left
-			be.extract(1, 11, 21, 31, 41, 51, 61, 71),
-			be.extract(2, 12, 22, 32, 42, 52, 62, 72), // right
+			be.extract_tuple( be.pattern(0) ), // left
+			be.extract_tuple( be.pattern(1) ),
+			be.extract_tuple( be.pattern(2) ), // right
 			// middle row
-			be.extract(10, 20, 30, 40, 50, 60, 70, 80),
-			be.extract(11, 21, 31, 41, 51, 61, 71, 81),
-			be.extract(12, 22, 32, 42, 52, 62, 72, 82),
+			be.extract_tuple( be.pattern(3) ),
+			be.extract_tuple( be.pattern(4) ),
+			be.extract_tuple( be.pattern(5) ),
 			// bottom row
-			be.extract(20, 30, 40, 50, 60, 70, 80, 90),
-			be.extract(21, 31, 41, 51, 61, 71, 81, 91),
-			be.extract(22, 32, 42, 52, 62, 72, 82, 92)
+			be.extract_tuple( be.pattern(6) ),
+			be.extract_tuple( be.pattern(7) ),
+			be.extract_tuple( be.pattern(8) )
 		};
 	}
 
 	std::array<uint64_t, 9> extract_fast() const
 	{
-		bit_extractor<intx::uint128, 100> be(_bits);
+		bit_extractor<intx::uint128, CELLAREA, CELLSIZE> be(_bits);
 		// skip the corners
 		return {
 			0,
-			be.extract(1, 11, 21, 31, 41, 51, 61, 71),
+			be.extract_tuple( be.pattern(1) ),
 			0,
 			// middle row
-			be.extract(10, 20, 30, 40, 50, 60, 70, 80),
-			be.extract(11, 21, 31, 41, 51, 61, 71, 81),
-			be.extract(12, 22, 32, 42, 52, 62, 72, 82),
+			be.extract_tuple( be.pattern(3) ),
+			be.extract_tuple( be.pattern(4) ),
+			be.extract_tuple( be.pattern(5) ),
 			// bottom row
 			0,
-			be.extract(21, 31, 41, 51, 61, 71, 81, 91),
+			be.extract_tuple( be.pattern(7) ),
 			0
 		};
 	}
diff --git a/src/lib/image_hash/average_hash.h b/src/lib/image_hash/average_hash.h
index 27cbb50..7802e1a 100644
--- a/src/lib/image_hash/average_hash.h
+++ b/src/lib/image_hash/average_hash.h
@@ -20,14 +20,14 @@ namespace image_hash
 		cv::Mat gray = img;
 		if (img.channels() != 1)
 			cv::cvtColor(gray, gray, cv::COLOR_RGB2GRAY);
-		if (gray.cols != 8 or gray.rows != 8)
+		if (gray.cols > 8 or gray.rows > 8)
 			cv::resize(gray, gray, cv::Size(8, 8));
 
 		if (threshold == 0)
 			threshold = Cell(gray).mean_grayscale();
 
 		uint64_t res = 0;
-		int bitpos = 63; // 8*8 - 1
+		int bitpos = gray.rows*gray.cols - 1; // ex: 8*8 - 1
 		for (int i = 0; i < gray.rows; ++i)
 		{
 			const uchar* p = gray.ptr<uchar>(i);
@@ -37,72 +37,39 @@ namespace image_hash
 		return res;
 	}
 
-	inline ahash_result special_case_fuzzy_ahash(const cv::Mat& gray, unsigned mode)
+	template <unsigned CELLSIZE>
+	inline ahash_result<CELLSIZE> fuzzy_ahash(const cv::Mat& img, uchar threshold=0, unsigned mode=ahash_result<CELLSIZE>::ALL)
 	{
-		// if the Mat is already 10x10 and threshold'd to (0, 0xFF), we can do some things...
-		intx::uint128 res(0);
-		int bitpos = 95; // 10*10 - 5
-		for (int i = 0; i < gray.rows; ++i)
-		{
-			const uchar* p = gray.ptr<uchar>(i);
-			for (int j = 0; j < gray.cols; j+=5, bitpos-=5)
-			{
-				const uint64_t* hax = reinterpret_cast<const uint64_t*>(p+j);
-				uint64_t mval = (*hax) & 0x101010101ULL;
-				const uint8_t* cv = reinterpret_cast<const uint8_t*>(&mval);
-				uint8_t val = cv[0] << 4 | cv[1] << 3 | cv[2] << 2 | cv[3] << 1 | cv[4];
-				// TODO:
-				/*if (bigEndian)
-					val = cv[7] << 4 | cv[6] << 3 | cv[5] << 2 | cv[4] << 1 | cv[3];*/ // ?
-
-				res |= intx::uint128(val) << bitpos;
-			}
-		}
-		return ahash_result(res, mode);
-	}
-
-	// need something like a bitset_extractor(), with an api like:
-	// bits.extract(0, 8,  9, 17,  18, 26,  27, 35,  36, 44,  45, 53,  54, 62,  63, 71)
-	//  ... probably using template magic. For our purposes, we need >= 8 pairs of bit indices, which will sum to a total of 64 bits
-	// or maybe a better api is:
-	// bits.extract(0, 9, 18, 27, 36, 45, 54, 63)
-	//  ... with each index corresponding to an 8 bit read?
-	//  ... this way, we could do compile time validation that the return value makes sense.
-	//  ... e.g. if we have 8 params, that means it's a 64 bit number being returned.
-	inline ahash_result fuzzy_ahash(const cv::Mat& img, uchar threshold=0, unsigned mode=ahash_result::ALL)
-	{
-		// return 9 uint64_ts, each representing an 8x8 section of the 10x10 img
+		// return 9 uint64_ts, each representing a 5x5 section of the 7x7 img, an 8x8 section of an 10x10 img, etc
 		cv::Mat gray = img;
 		if (img.channels() != 1)
 			cv::cvtColor(gray, gray, cv::COLOR_RGB2GRAY);
-		if (gray.cols != 10 or gray.rows != 10)
-			cv::resize(gray, gray, cv::Size(10, 10));
 
 		if (threshold == 0)
 			threshold = Cell(gray).mean_grayscale();
-		else if (threshold == 0xFF)
-			return special_case_fuzzy_ahash(gray, mode);
 
 		intx::uint128 res(0);
-		int bitpos = 99; // 10*10 - 1
+		int bitpos = gray.cols*gray.rows - 1; // 8*8 - 1
 		for (int i = 0; i < gray.rows; ++i)
 		{
 			const uchar* p = gray.ptr<uchar>(i);
 			for (int j = 0; j < gray.cols; ++j, --bitpos)
 				res |= intx::uint128(p[j] > threshold) << bitpos;
 		}
-		return ahash_result(res, mode);
+		return ahash_result<CELLSIZE>(res, mode);
 	}
 
-	inline ahash_result fuzzy_ahash(const bitmatrix& img, unsigned mode=ahash_result::ALL)
+	template <unsigned CELLSIZE>
+	inline ahash_result<CELLSIZE> fuzzy_ahash(const bitmatrix& img, unsigned mode=ahash_result<CELLSIZE>::ALL)
 	{
+		const unsigned readlen = CELLSIZE+2;
 		intx::uint128 res(0);
-		int bitpos = 90; // 10*10 - 10
-		for (int i = 0; i < 10; ++i, bitpos-=10)
+		int bitpos = readlen*readlen - readlen; // 7*7 - 7 ..
+		for (unsigned i = 0; i < readlen; ++i, bitpos-=readlen)
 		{
-			unsigned r = img.get(0, i, 10);
-			res |= intx::uint128(r) << bitpos;
+			intx::uint128 r = img.get(0, i, readlen);
+			res |= r << bitpos;
 		}
-		return ahash_result(res, mode);
+		return ahash_result<CELLSIZE>(res, mode);
 	}
 }
diff --git a/src/lib/image_hash/bit_extractor.h b/src/lib/image_hash/bit_extractor.h
index d78d658..9769be3 100644
--- a/src/lib/image_hash/bit_extractor.h
+++ b/src/lib/image_hash/bit_extractor.h
@@ -2,13 +2,35 @@
 #pragma once
 
 #include <iostream>
+#include <tuple>
 
-template<typename C, size_t N>
+// 2(?) <= READLEN <= 8
+template<typename C, size_t N, size_t READLEN>
 class bit_extractor
 {
+protected:
+	static constexpr uint64_t BITMASK = (1 << READLEN) - 1; // e.g. 0xFF, 0x1F, 0xF
+
+public:
+	template <size_t iterations=READLEN>
+	static constexpr auto get_offsets(unsigned offset)
+	{
+		if constexpr (iterations == 1)
+			return std::make_tuple(offset);
+		else
+			return std::tuple_cat(std::make_tuple(offset), get_offsets<iterations-1>(offset+READLEN+2));
+	}
+
+	static constexpr auto pattern(unsigned id)
+	{
+		// convert our numbering scheme in extract_fast() into the bitpositions
+		// that we'll use to extract our (e.g.) 64 bits (8x8) from the 100 bits (10x10) we have.
+		return get_offsets(id%3 + (id/3)*(READLEN+2));
+	}
+
 public:
 	bit_extractor(const C& bits)
-	    : _bits(bits)
+		: _bits(bits)
 	{}
 
 	template<typename... T>
@@ -22,10 +44,23 @@ class bit_extractor
 	{
 		constexpr auto byte_offset = sizeof...(T);
 
-		uint64_t total = ((uint64_t)(_bits >> (N - bit_offset - 8)) & 0xFF) << (byte_offset << 3); // if byte_offset is 1, we want to shift 8. if 2, 16....
+		// grab the front READLEN bits. Then put them in the right place in the uint64_t output.
+		// if byte_offset is 1, we want to shift READLEN. if 2, READLEN*2...
+		uint64_t total = ((uint64_t)(_bits >> (N - bit_offset - READLEN)) & BITMASK) << (byte_offset * READLEN);
 		return total | extract(t...);
 	}
 
+	template <typename Tuple, size_t... I>
+	constexpr uint64_t extract_tuple(Tuple const& tuple, std::index_sequence<I...>) {
+		return extract(std::get<I>(tuple)...);
+	}
+
+	template <typename Tuple>
+	constexpr uint64_t extract_tuple(Tuple const& tuple) {
+		return extract_tuple(tuple, std::make_index_sequence<std::tuple_size<Tuple>::value>());
+	}
+
+
 protected:
 	C _bits;
 };
diff --git a/src/lib/image_hash/test/averageHashTest.cpp b/src/lib/image_hash/test/averageHashTest.cpp
index d177cc1..e2ae2d3 100644
--- a/src/lib/image_hash/test/averageHashTest.cpp
+++ b/src/lib/image_hash/test/averageHashTest.cpp
@@ -13,25 +13,43 @@
 
 using std::string;
 
-TEST_CASE( "averageHashTest/testLight", "[unit]" )
+TEST_CASE( "averageHashTest/test5x5.Light", "[unit]" )
+{
+	cv::Mat tile = cimbar::getTile(2, 0, false);
+	assertEquals(0x8cef, image_hash::average_hash(tile));
+
+	tile = cimbar::getTile(2, 1, false);
+	assertEquals(0xf38c20, image_hash::average_hash(tile));
+}
+
+TEST_CASE( "averageHashTest/test5x5.Dark", "[unit]" )
+{
+	cv::Mat tile = cimbar::getTile(2, 0, true);
+	assertEquals(0x1ff7310, image_hash::average_hash(tile));
+
+	tile = cimbar::getTile(2, 1, true);
+	assertEquals(0x10c73df, image_hash::average_hash(tile));
+}
+
+TEST_CASE( "averageHashTest/test8x8.Light", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, false);
 	assertEquals(0x103070f1f3f7f, image_hash::average_hash(tile));
 
-	tile = cimbar::getTile(4, 0, false);
-	assertEquals(0x103070f1f3f7f, image_hash::average_hash(tile));
+	tile = cimbar::getTile(4, 1, false);
+	assertEquals(0x7f3f1f0f07030100, image_hash::average_hash(tile));
 }
 
-TEST_CASE( "averageHashTest/testDark", "[unit]" )
+TEST_CASE( "averageHashTest/test8x8.Dark", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, true);
 	assertEquals(0xfffefcf8f0e0c080, image_hash::average_hash(tile));
 
-	tile = cimbar::getTile(4, 0, true);
-	assertEquals(0xfffefcf8f0e0c080, image_hash::average_hash(tile));
+	tile = cimbar::getTile(4, 1, true);
+	assertEquals(0x80c0e0f0f8fcfeff, image_hash::average_hash(tile));
 }
 
-TEST_CASE( "averageHashTest/testResize", "[unit]" )
+TEST_CASE( "averageHashTest/test8x8.Resize", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, true);
 
@@ -39,3 +57,4 @@ TEST_CASE( "averageHashTest/testResize", "[unit]" )
 	cv::resize(tile, big, cv::Size(32, 32));
 	assertEquals(0xfffefcf8f0e0c080, image_hash::average_hash(big));
 }
+
diff --git a/src/lib/image_hash/test/bitExtractorTest.cpp b/src/lib/image_hash/test/bitExtractorTest.cpp
index 9848b95..32e8f93 100644
--- a/src/lib/image_hash/test/bitExtractorTest.cpp
+++ b/src/lib/image_hash/test/bitExtractorTest.cpp
@@ -3,19 +3,52 @@
 
 #include "bit_extractor.h"
 #include "intx/intx.hpp"
+#include "serialize/format.h"
 
-#include <bitset>
-#include <iostream>
-#include <sstream>
 #include <string>
-#include <vector>
+#include <tuple>
+
+namespace {
+	template<typename... T>
+	std::string tuple_to_str(const std::tuple<T...>& tup)
+	{
+		std::string res;
+		std::apply([&res](auto&&... args) {((res += fmt::format("{} ", args)), ...);}, tup);
+		if (res.size() > 0)
+			res = res.substr(0, res.size()-1);
+		return res;
+	}
+}
+
+TEST_CASE( "bitExtractorTest/testDefault.4", "[unit]" )
+{
+	uint64_t bits = 0x11d07e1f;
+	bit_extractor<uint64_t, 32, 4> be(bits);
+
+	// we're just reading 4 bits at a time.
+	assertEquals( 0x1d, be.extract(0, 8) );    // 0001 1101
+	assertEquals( 0x71, be.extract(16, 24) );  // 0x7 0x1
+	assertEquals( 0x1e, be.extract(0, 20) );
+	assertEquals( 0x0f, be.extract(12, 28) );
+	assertEquals( 0x1d, be.extract(24, 8) );
+}
 
-using std::string;
 
-TEST_CASE( "bitExtractorTest/testDefault", "[unit]" )
+TEST_CASE( "bitExtractorTest/testDefault.5", "[unit]" )
 {
-	intx::uint128 bits = 0x11d07e1f;
-	bit_extractor<intx::uint128, 32> be(bits);
+	uint64_t bits = 0x11d07e1f;
+	bit_extractor<uint64_t, 32, 5> be(bits);
+
+	assertEquals(  0x48, be.extract(0, 10) );   // 00010 01000
+	assertEquals(  0xfc, be.extract(15, 20) );  // 00111 11100
+	assertEquals(  0x9c, be.extract(1, 20) );   // 00100 11100
+	assertEquals( 0x1e7, be.extract(16, 25) );  // 01111 00111
+}
+
+TEST_CASE( "bitExtractorTest/testDefault.8", "[unit]" )
+{
+	uint64_t bits = 0x11d07e1f;
+	bit_extractor<uint64_t, 32, 8> be(bits);
 
 	assertEquals( 0x11d0, be.extract(0, 8) );
 	assertEquals( 0x7e1f, be.extract(16, 24) );
@@ -23,13 +56,14 @@ TEST_CASE( "bitExtractorTest/testDefault", "[unit]" )
 	assertEquals( 0x1fd0, be.extract(24, 8) );
 }
 
+
 TEST_CASE( "bitExtractorTest/testLargerValue.1", "[unit]" )
 {
 	intx::uint128 bits(0);
 	for (int i = 0; i < 81; ++i)
 		bits = (bits << 1) | (i%3 == 0);
 
-	bit_extractor<intx::uint128, 81> be(bits);
+	bit_extractor<intx::uint128, 81, 8> be(bits);
 	uint64_t res = be.extract(0, 9, 18, 27, 36, 45, 54, 63);
 	assertEquals( 0x9292929292929292, res );
 }
@@ -39,7 +73,7 @@ TEST_CASE( "bitExtractorTest/testLargerValue.2", "[unit]" )
 	intx::uint128 bits{0xF83C0E030080000ULL, 0xFFBFCFE3FULL};
 	assertEquals( "ffbfcfe3f0f83c0e030080000", intx::hex(bits) );  // sanity check
 
-	bit_extractor<intx::uint128, 100> be(bits);
+	bit_extractor<intx::uint128, 100, 8> be(bits);
 	uint64_t res = be.extract(1, 11, 21, 31);
 	assertEquals( 0xfffefcf8, res );
 
@@ -56,3 +90,94 @@ TEST_CASE( "bitExtractorTest/testLargerValue.2", "[unit]" )
 	assertEquals( 0xf8f0e0c080000000ULL, res );
 }
 
+TEST_CASE( "bitExtractorTest/testTuple.5", "[unit]" )
+{
+	uint64_t bits = 0x11d07e1f;
+	bit_extractor<uint64_t, 32, 5> be(bits);
+
+	auto tup = be.pattern(0);
+	assertEquals( "0 7 14 21 28", tuple_to_str(tup) );
+
+	assertEquals(  0x2e8f00, be.extract(0, 7, 14, 21, 28) );
+	assertEquals(  0x2e8f00, be.extract_tuple(tup) );
+}
+
+TEST_CASE( "bitExtractorTest/testTuple.8", "[unit]" )
+{
+	intx::uint128 bits{0xF83C0E030080000ULL, 0xFFBFCFE3FULL};
+	bit_extractor<intx::uint128, 100, 8> be(bits);
+
+	auto tup = be.pattern(3);
+	assertEquals( "10 20 30 40 50 60 70 80", tuple_to_str(tup) );
+
+	assertEquals(  0xfffefcf8f0e0c080, be.extract(10, 20, 30, 40, 50, 60, 70, 80) );
+	assertEquals(  0xfffefcf8f0e0c080, be.extract_tuple(tup) );
+}
+
+TEST_CASE( "bitExtractorTest/testTuplePatterns.5", "[unit]" )
+{
+	uint64_t bits = 0x11d07e1f;
+	bit_extractor<uint64_t, 32, 5> be(bits);
+
+	std::tuple<unsigned, unsigned, unsigned, unsigned, unsigned> tup = be.pattern(0);
+	assertEquals( "0 7 14 21 28", tuple_to_str(tup) );
+	assertEquals( "0 7 14 21 28", tuple_to_str(be.get_offsets(0)) );
+
+	assertEquals( "1 8 15 22 29", tuple_to_str(be.pattern(1)) );
+	assertEquals( "1 8 15 22 29", tuple_to_str(be.get_offsets(1)) );
+
+	assertEquals( "2 9 16 23 30", tuple_to_str(be.pattern(2)) );
+	assertEquals( "2 9 16 23 30", tuple_to_str(be.get_offsets(2)) );
+
+	assertEquals( "7 14 21 28 35", tuple_to_str(be.pattern(3)) );
+	assertEquals( "7 14 21 28 35", tuple_to_str(be.get_offsets(7)) );
+
+	assertEquals( "8 15 22 29 36", tuple_to_str(be.pattern(4)) );
+	assertEquals( "8 15 22 29 36", tuple_to_str(be.get_offsets(8)) );
+
+	assertEquals( "9 16 23 30 37", tuple_to_str(be.pattern(5)) );
+	assertEquals( "9 16 23 30 37", tuple_to_str(be.get_offsets(9)) );
+
+	assertEquals( "14 21 28 35 42", tuple_to_str(be.pattern(6)) );
+	assertEquals( "14 21 28 35 42", tuple_to_str(be.get_offsets(14)) );
+
+	assertEquals( "15 22 29 36 43", tuple_to_str(be.pattern(7)) );
+	assertEquals( "15 22 29 36 43", tuple_to_str(be.get_offsets(15)) );
+
+	assertEquals( "16 23 30 37 44", tuple_to_str(be.pattern(8)) );
+	assertEquals( "16 23 30 37 44", tuple_to_str(be.get_offsets(16)) );
+}
+
+TEST_CASE( "bitExtractorTest/testTuplePatterns.8", "[unit]" )
+{
+	intx::uint128 bits{0xF83C0E030080000ULL, 0xFFBFCFE3FULL};
+	bit_extractor<intx::uint128, 100, 8> be(bits);
+
+	std::tuple<unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned> tup = be.pattern(0);
+	assertEquals( "0 10 20 30 40 50 60 70", tuple_to_str(tup) );
+	assertEquals( "0 10 20 30 40 50 60 70", tuple_to_str(be.get_offsets(0)) );
+
+	assertEquals( "1 11 21 31 41 51 61 71", tuple_to_str(be.pattern(1)) );
+	assertEquals( "1 11 21 31 41 51 61 71", tuple_to_str(be.get_offsets(1)) );
+
+	assertEquals( "2 12 22 32 42 52 62 72", tuple_to_str(be.pattern(2)) );
+	assertEquals( "2 12 22 32 42 52 62 72", tuple_to_str(be.get_offsets(2)) );
+
+	assertEquals( "10 20 30 40 50 60 70 80", tuple_to_str(be.pattern(3)) );
+	assertEquals( "10 20 30 40 50 60 70 80", tuple_to_str(be.get_offsets(10)) );
+
+	assertEquals( "11 21 31 41 51 61 71 81", tuple_to_str(be.pattern(4)) );
+	assertEquals( "11 21 31 41 51 61 71 81", tuple_to_str(be.get_offsets(11)) );
+
+	assertEquals( "12 22 32 42 52 62 72 82", tuple_to_str(be.pattern(5)) );
+	assertEquals( "12 22 32 42 52 62 72 82", tuple_to_str(be.get_offsets(12)) );
+
+	assertEquals( "20 30 40 50 60 70 80 90", tuple_to_str(be.pattern(6)) );
+	assertEquals( "20 30 40 50 60 70 80 90", tuple_to_str(be.get_offsets(20)) );
+
+	assertEquals( "21 31 41 51 61 71 81 91", tuple_to_str(be.pattern(7)) );
+	assertEquals( "21 31 41 51 61 71 81 91", tuple_to_str(be.get_offsets(21)) );
+
+	assertEquals( "22 32 42 52 62 72 82 92", tuple_to_str(be.pattern(8)) );
+	assertEquals( "22 32 42 52 62 72 82 92", tuple_to_str(be.get_offsets(22)) );
+}
diff --git a/src/lib/image_hash/test/fuzzyAhashTest.cpp b/src/lib/image_hash/test/fuzzyAhashTest.cpp
index cff8d96..f431d0c 100644
--- a/src/lib/image_hash/test/fuzzyAhashTest.cpp
+++ b/src/lib/image_hash/test/fuzzyAhashTest.cpp
@@ -16,7 +16,20 @@
 using std::string;
 
 namespace {
-	cv::Mat embedTile(const cv::Mat& tile, bool binaryThresh=false)
+	cv::Mat embedTile5x5(const cv::Mat& tile, bool binaryThresh=false)
+	{
+		cv::Mat sevens(7, 7, tile.type(), cv::Scalar(0, 0, 0));
+		tile.copyTo(sevens(cv::Rect(cv::Point(1, 1), tile.size())));
+
+		if (binaryThresh)
+		{
+			cv::cvtColor(sevens, sevens, cv::COLOR_RGB2GRAY);
+			cv::adaptiveThreshold(sevens, sevens, 0xFF, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 3, 0);
+		}
+		return sevens;
+	}
+
+	cv::Mat embedTile8x8(const cv::Mat& tile, bool binaryThresh=false)
 	{
 		cv::Mat tenxten(10, 10, tile.type(), cv::Scalar(0, 0, 0));
 		tile.copyTo(tenxten(cv::Rect(cv::Point(1, 1), tile.size())));
@@ -24,16 +37,40 @@ namespace {
 		if (binaryThresh)
 		{
 			cv::cvtColor(tenxten, tenxten, cv::COLOR_RGB2GRAY);
-			cv::adaptiveThreshold(tenxten, tenxten, 0xFF, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 5, 0);
+			cv::adaptiveThreshold(tenxten, tenxten, 0xFF, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 3, 0);
 		}
 		return tenxten;
 	}
 }
 
-TEST_CASE( "fuzzyAhashTest/testCorrectness", "[unit]" )
+TEST_CASE( "fuzzyAhashTest/testCorrectness5", "[unit]" )
+{
+	cv::Mat tile = cimbar::getTile(2, 0, true);
+	cv::Mat tenxten = embedTile5x5(tile);
+
+	// compute the hashes we expect
+	std::vector<uint64_t> expected;
+	for (const std::pair<int, int>& drift : CellDrift::driftPairs)
+	{
+		cv::Rect crop(drift.first + 1, drift.second + 1, 5, 5);
+		cv::Mat img = tenxten(crop);
+		expected.push_back(image_hash::average_hash(img, 64)); // we pass in a threshold value to match what fuzzy_ahash will compute
+	}
+
+	// do the real work
+	auto actual = image_hash::fuzzy_ahash<5>(tenxten);
+
+	for (unsigned i = 0; i < actual.size(); ++i)
+		DYNAMIC_SECTION( "are we correct? : " << i )
+		{
+			assertEquals(expected[i], actual[i]);
+		}
+}
+
+TEST_CASE( "fuzzyAhashTest/testCorrectness8", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, true);
-	cv::Mat tenxten = embedTile(tile);
+	cv::Mat tenxten = embedTile8x8(tile);
 
 	// compute the hashes we expect
 	std::vector<uint64_t> expected;
@@ -45,7 +82,7 @@ TEST_CASE( "fuzzyAhashTest/testCorrectness", "[unit]" )
 	}
 
 	// do the real work
-	auto actual = image_hash::fuzzy_ahash(tenxten);
+	auto actual = image_hash::fuzzy_ahash<8>(tenxten);
 
 	for (unsigned i = 0; i < actual.size(); ++i)
 		DYNAMIC_SECTION( "are we correct? : " << i )
@@ -57,7 +94,7 @@ TEST_CASE( "fuzzyAhashTest/testCorrectness", "[unit]" )
 TEST_CASE( "fuzzyAhashTest/testIterator", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, true);
-	cv::Mat tenxten = embedTile(tile);
+	cv::Mat tenxten = embedTile8x8(tile);
 
 	// compute the hashes we expect
 	std::vector<uint64_t> expected;
@@ -69,7 +106,7 @@ TEST_CASE( "fuzzyAhashTest/testIterator", "[unit]" )
 	}
 
 	// do the real work
-	image_hash::ahash_result actual = image_hash::fuzzy_ahash(tenxten);
+	image_hash::ahash_result actual = image_hash::fuzzy_ahash<8>(tenxten);
 	int count = 0;
 	for (auto it : actual)
 	{
@@ -97,7 +134,7 @@ TEST_CASE( "fuzzyAhashTest/testIterator", "[unit]" )
 TEST_CASE( "fuzzyAhashTest/testPreThreshold", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, true);
-	cv::Mat tenxten = embedTile(tile, true);
+	cv::Mat tenxten = embedTile8x8(tile, true);
 
 	// compute the hashes we expect
 	std::vector<uint64_t> expected;
@@ -109,7 +146,7 @@ TEST_CASE( "fuzzyAhashTest/testPreThreshold", "[unit]" )
 	}
 
 	// do the real work
-	auto actual = image_hash::fuzzy_ahash(tenxten, 0xFE);
+	auto actual = image_hash::fuzzy_ahash<8>(tenxten, 0xFE);
 
 	for (unsigned i = 0; i < actual.size(); ++i)
 		DYNAMIC_SECTION( "are we correct? : " << i )
@@ -118,10 +155,10 @@ TEST_CASE( "fuzzyAhashTest/testPreThreshold", "[unit]" )
 		}
 }
 
-TEST_CASE( "fuzzyAhashTest/testPreThreshold.SpecialCase", "[unit]" )
+TEST_CASE( "fuzzyAhashTest/testPreThreshold.BitMatrix", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, true);
-	cv::Mat tenxten = embedTile(tile, true);
+	cv::Mat tenxten = embedTile8x8(tile, true);
 
 	// compute the hashes we expect
 	std::vector<uint64_t> expected;
@@ -132,10 +169,13 @@ TEST_CASE( "fuzzyAhashTest/testPreThreshold.SpecialCase", "[unit]" )
 		expected.push_back(image_hash::average_hash(img, 64));
 	}
 
+	bitbuffer bb;
+	bitbuffer::writer writer(bb);
+	bitmatrix::mat_to_bitbuffer(tenxten, writer);
+
 	// do the real work
-	// 0xFF is a special case. It says we *only* care about 0xFF values,
-	// e.g. we can make some assumptions about the input data that might help us optimize...
-	auto actual = image_hash::fuzzy_ahash(tenxten, 0xFF);
+	bitmatrix bm(bb, 10, 10);
+	auto actual = image_hash::fuzzy_ahash<8>(bm);
 
 	for (unsigned i = 0; i < actual.size(); ++i)
 		DYNAMIC_SECTION( "are we correct? : " << i )
@@ -144,11 +184,10 @@ TEST_CASE( "fuzzyAhashTest/testPreThreshold.SpecialCase", "[unit]" )
 		}
 }
 
-
-TEST_CASE( "fuzzyAhashTest/testPreThreshold.BitMatrix", "[unit]" )
+TEST_CASE( "fuzzyAhashTest/testPreThreshold.BitMatrix8.Fast", "[unit]" )
 {
 	cv::Mat tile = cimbar::getTile(4, 0, true);
-	cv::Mat tenxten = embedTile(tile, true);
+	cv::Mat tenxten = embedTile8x8(tile, true);
 
 	// compute the hashes we expect
 	std::vector<uint64_t> expected;
@@ -163,9 +202,50 @@ TEST_CASE( "fuzzyAhashTest/testPreThreshold.BitMatrix", "[unit]" )
 	bitbuffer::writer writer(bb);
 	bitmatrix::mat_to_bitbuffer(tenxten, writer);
 
+	// clear the hashes we don't care about
+	expected[0] = 0;
+	expected[2] = 0;
+	expected[6] = 0;
+	expected[8] = 0;
+
 	// do the real work
 	bitmatrix bm(bb, 10, 10);
-	auto actual = image_hash::fuzzy_ahash(bm);
+	auto actual = image_hash::fuzzy_ahash<8>(bm, image_hash::ahash_result<8>::FAST);
+
+	for (unsigned i = 0; i < actual.size(); ++i)
+		DYNAMIC_SECTION( "are we correct? : " << i )
+		{
+			assertEquals(expected[i], actual[i]);
+		}
+}
+
+TEST_CASE( "fuzzyAhashTest/testPreThreshold.BitMatrix5.Fast", "[unit]" )
+{
+	cv::Mat tile = cimbar::getTile(2, 0, true);
+	cv::Mat tenxten = embedTile5x5(tile, true);
+
+	// compute the hashes we expect
+	std::vector<uint64_t> expected;
+	for (const std::pair<int, int>& drift : CellDrift::driftPairs)
+	{
+		cv::Rect crop(drift.first + 1, drift.second + 1, 5, 5);
+		cv::Mat img = tenxten(crop);
+		expected.push_back(image_hash::average_hash(img, 64));
+	}
+
+	bitbuffer bb;
+	bitbuffer::writer writer(bb);
+	bitmatrix::mat_to_bitbuffer(tenxten, writer);
+
+	// clear the hashes we don't care about
+	expected[0] = 0;
+	expected[2] = 0;
+	expected[6] = 0;
+	expected[8] = 0;
+
+	// do the real work
+	bitmatrix bm(bb, 7, 7);
+	auto actual = image_hash::fuzzy_ahash<5>(bm, image_hash::ahash_result<5>::FAST);
 
 	for (unsigned i = 0; i < actual.size(); ++i)
 		DYNAMIC_SECTION( "are we correct? : " << i )
diff --git a/test/py/__init__.py b/test/py/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/test/py/helpers.py b/test/py/helpers.py
new file mode 100644
index 0000000..759f124
--- /dev/null
+++ b/test/py/helpers.py
@@ -0,0 +1,16 @@
+from os.path import join, realpath, dirname
+from tempfile import TemporaryDirectory
+
+CIMBAR_SRC = realpath(join(dirname(realpath(__file__)), '..', '..'))
+BIN_DIR = join(CIMBAR_SRC, 'dist', 'bin')
+
+
+class TestDirMixin():
+    def setUp(self):
+        self.working_dir = TemporaryDirectory()
+        super().setUp()
+
+    def tearDown(self):
+        super().tearDown()
+        with self.working_dir:
+            pass
\ No newline at end of file
diff --git a/test/py/test_cimbar_cli.py b/test/py/test_cimbar_cli.py
new file mode 100644
index 0000000..f809f05
--- /dev/null
+++ b/test/py/test_cimbar_cli.py
@@ -0,0 +1,89 @@
+import subprocess
+from subprocess import PIPE
+from os.path import join as path_join, getsize
+from unittest import TestCase
+from unittest.mock import patch
+
+from helpers import TestDirMixin, CIMBAR_SRC, BIN_DIR
+
+
+CIMBAR_EXE = path_join(BIN_DIR, 'cimbar')
+
+
+def _get_command(*args):
+    cmd = [CIMBAR_EXE]
+    for arg in args:
+        if isinstance(arg, str):
+            cmd += arg.split(' ')
+        else:
+            cmd += arg
+    return cmd
+
+# look in dist/bin/ for executables
+# run them, confirm a few boring command results against samples(?)
+# at the very least, confirm a roundtrip and cli options....
+
+
+class CimbarCliTest(TestDirMixin, TestCase):
+    def test_roundtrip_oneshot(self):
+        # encode
+        infile = path_join(CIMBAR_SRC, 'LICENSE')
+        outprefix = path_join(self.working_dir.name, 'img')
+        cmd = _get_command('--encode -i', infile, '-o', outprefix)
+
+        res = subprocess.run(cmd, stdout=PIPE)
+        self.assertEqual(0, res.returncode)
+
+        encoded_img = f'{outprefix}_0.png'
+        self.assertTrue(getsize(encoded_img) > 30000)
+
+        # decode
+        cmd = _get_command('-i', encoded_img, '-o', self.working_dir.name)
+        res = subprocess.run(cmd, stdout=PIPE)
+        self.assertEqual(0, res.returncode)
+
+        # filename in stdout
+        decoded_file = res.stdout.strip().decode('utf-8')
+        self.assertTrue(self.working_dir.name in decoded_file)
+
+        with open(infile) as r:
+            expected = r.read()
+        with open(decoded_file) as r:
+            actual = r.read()
+
+        self.assertEqual(expected, actual)
+
+    def test_roundtrip_stdin(self):
+        # encode
+        infile = path_join(CIMBAR_SRC, 'LICENSE')
+        outprefix = path_join(self.working_dir.name, 'img')
+        cmd = _get_command('--encode -o', outprefix)
+
+        res = subprocess.run(
+            cmd, input=infile.encode('utf-8'), stdout=PIPE
+        )
+
+        self.assertEqual(0, res.returncode)
+
+        encoded_img = f'{outprefix}_0.png'
+        self.assertTrue(getsize(encoded_img) > 30000)
+
+        # decode defaults to cwd -- which should be self.working_dir
+        cmd = _get_command()
+        res = subprocess.run(
+            cmd, input=encoded_img.encode('utf-8'), stdout=PIPE,
+            cwd=self.working_dir.name,
+        )
+        self.assertEqual(0, res.returncode)
+
+        # filename in stdout
+        decoded_file = res.stdout.strip().decode('utf-8')
+        self.assertTrue(self.working_dir.name in decoded_file)
+
+        with open(infile) as r:
+            expected = r.read()
+        with open(decoded_file) as r:
+            actual = r.read()
+
+        self.assertEqual(expected, actual)
+
diff --git a/web/main.js b/web/main.js
index e77901f..17f94b6 100644
--- a/web/main.js
+++ b/web/main.js
@@ -157,7 +157,7 @@ return {
 
   setColorBits : function(color_bits)
   {
-    Module._configure(color_bits, 30, 6);
+    Module._configure(color_bits, 255, 255);
 
     var nav = document.getElementById("nav-container");
     if (color_bits == 2) {

From 92f3b664c8bb018818836cef34715052ac464819 Mon Sep 17 00:00:00 2001
From: sz <sz@recv.cc>
Date: Sat, 24 Jun 2023 16:10:01 -0500
Subject: [PATCH 3/3] v0.5.13 version bump

---
 app/build.gradle            | 4 ++--
 app/src/cpp/cfc-cpp/jni.cpp | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/app/build.gradle b/app/build.gradle
index c69bac9..f5eb8f0 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -8,8 +8,8 @@ android {
         applicationId "org.cimbar.camerafilecopy"
         minSdkVersion 21
         targetSdkVersion 33
-        versionCode 8
-        versionName "0.5.12+a"
+        versionCode 9
+        versionName "0.5.13"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
         externalNativeBuild {
             cmake {
diff --git a/app/src/cpp/cfc-cpp/jni.cpp b/app/src/cpp/cfc-cpp/jni.cpp
index 44be269..95d2540 100644
--- a/app/src/cpp/cfc-cpp/jni.cpp
+++ b/app/src/cpp/cfc-cpp/jni.cpp
@@ -119,7 +119,7 @@ namespace {
 	{
 		std::stringstream sstop;
 		sstop << "cfc using " << proc.num_threads() << " thread(s). " << proc.color_bits() << "..." << proc.backlog() << "? ";
-		sstop << (MultiThreadedDecoder::bytes / std::max<double>(1, MultiThreadedDecoder::decoded)) << "b v0.5.12";
+		sstop << (MultiThreadedDecoder::bytes / std::max<double>(1, MultiThreadedDecoder::decoded)) << "b v0.5.13";
 		std::stringstream ssmid;
 		ssmid << "#: " << MultiThreadedDecoder::perfect << " / " << MultiThreadedDecoder::decoded << " / " << MultiThreadedDecoder::scanned << " / " << _calls;
 		std::stringstream ssperf;