V0.4.0加入锁定二维码

This commit is contained in:
zhy
2026-08-10 17:09:30 +08:00
parent d885259e2b
commit 241e22abea
34 changed files with 1754 additions and 985 deletions
+39 -27
View File
@@ -1,55 +1,67 @@
# QFT v0.3.0-rc3 implementation status # QFT v0.4.0-rc2 implementation status
## Windows → Android optical ## Windows → Android optical
- [x] QFT1 manifest/data/end wire format - [x] QFT2 manifest/data/end frame format
- [x] QFT2 Base45 text layer; Android Result.text decode
- [x] QFT1 legacy receive compatibility
- [x] CRC32 per frame + SHA-256 whole file - [x] CRC32 per frame + SHA-256 whole file
- [x] 1 QR / 4 QR per page - [x] **single large QR only**; 2×2 / 4-channel removed
- [x] Windows target refresh 1~60 FPS - [x] default 450-byte DATA payload
- [x] 4-code default, 900-byte payload - [x] QR-L + complete 4-module quiet zone
- [x] Windows target display 5~60 FPS
- [x] draggable control/QR split pane
- [x] focus-QR mode and QR zoom
- [x] Rayon background pre-encoding - [x] Rayon background pre-encoding
- [x] reused egui GPU TextureHandle - [x] reused egui GPU TextureHandle / NEAREST sampling
- [x] positioned source reads; no whole-file mmap - [x] positioned source reads; no whole-file mmap
- [x] bounded pre-render cache; 1.1GiB process design ceiling - [x] bounded pre-render cache; 1100 MiB process design budget
- [x] Android 4-region concurrent decoder - [x] Android centered acquisition + finder-point ROI lock
- [x] CameraX KEEP_ONLY_LATEST - [x] smoothed moving ROI + progressive miss expansion/reacquire
- [x] no whole-frame rotation/copy in hot path - [x] dynamic overlay: search/green lock/yellow miss/outside dim
- [x] runtime scan FPS / decoded QR/s status - [x] lock-centered periodic AF/AE
- [x] synthetic 4/4 visual QR decode test - [x] Android 640×480 ImageAnalysis + KEEP_ONLY_LATEST
- [ ] physical 60Hz/120Hz monitor × multiple Android camera hardware matrix - [x] Camera2Interop advertised AE FPS range request up to 60
- [x] automatic fallback when an OEM rejects explicit FPS/stream combination
- [x] reusable Y-plane `GrayFrameBuffer`
- [x] GlobalHistogram hot path + sparse Hybrid fallback
- [x] duplicate decoded optical frames suppressed before assembler
- [x] runtime camera FPS / decoded/s / distinct-new-frame/s / decode-ms UI
- [x] synthetic QFT2 v15 full-frame + ROI visual decode test
- [ ] physical 30/45/60Hz display × Android camera throughput matrix
## Android → Windows ## Android → Windows
- [x] QFTPAIR2 compact pairing QR - [x] QFTPAIR2 compact pairing QR
- [x] persistent per-PC Direct AP identity + per-session token - [x] persistent per-PC Direct AP identity + per-session token
- [x] one fast endpoint hint in Direct pairing QR - [x] Windows Wi-Fi Direct Legacy AP implementation
- [x] Windows Wi-Fi Direct Legacy AP code
- [x] Android 10+ WifiNetworkSpecifier path - [x] Android 10+ WifiNetworkSpecifier path
- [x] Android 7~9 legacy Wi-Fi path - [x] Android 7~9 legacy Wi-Fi path
- [x] wait for actual IPv4/link route before discovery - [x] wait for actual IPv4/link route before discovery
- [x] UDP QFTDISC2 receiver discovery - [x] UDP QFTDISC2 receiver discovery
- [x] directed broadcast + real gateway discovery - [x] QR endpoint + gateway + directed broadcast + subnet fallback
- [x] bounded /24 concurrent subnet fallback - [x] HTTP bound to selected Android Network
- [x] local cleartext network security config - [x] local cleartext network security config
- [x] private/local IPv4 + session-token validation - [x] local/private IPv4 + session-token validation
- [x] Parallel v2 upload init/chunk/finish - [x] Parallel v2 init/chunk/finish
- [x] adaptive 4/8/16 MiB chunk size - [x] adaptive 4/8/16 MiB chunks
- [x] up to 8 Android workers per file - [x] up to 8 Android workers per file
- [x] Windows concurrent positioned writes - [x] Windows positioned concurrent writes
- [x] temporary `.qftpart`, final SHA-256 and rename - [x] temporary `.qftpart`, final SHA-256 and rename
- [x] legacy single-stream fallback - [x] loopback UDP + HTTP + out-of-order parallel integration test
- [x] loopback UDP + HTTP + 8-worker integration test
- [ ] physical Windows Wi-Fi Direct adapter / driver / firewall matrix - [ ] physical Windows Wi-Fi Direct adapter / driver / firewall matrix
## Android compatibility ## Android compatibility
- [x] minSdk 24 (Android 7.0) - [x] minSdk 24 (Android 7.0)
- [x] legacy WRITE_EXTERNAL_STORAGE path <= Android 9 - [x] WRITE_EXTERNAL_STORAGE <= Android 9
- [x] MediaStore Downloads >= Android 10 - [x] MediaStore Downloads >= Android 10
- [x] ACCESS_FINE_LOCATION compatibility <= Android 12 - [x] ACCESS_FINE_LOCATION compatibility <= Android 12
- [x] NEARBY_WIFI_DEVICES >= Android 13 - [x] NEARBY_WIFI_DEVICES >= Android 13
- [x] no `java.util.Base64` dependency in app source - [x] no `java.util.Base64` dependency in app source
- [x] key Kotlin protocol/pairing/upload/scanner source syntax tests in the build environment - [x] host Kotlin QFT2/Base45 + LockRect runtime smoke
- [ ] APK installation/runtime matrix on Android 7/8/9/10/11/12/13/14/15/16+ physical/emulated devices - [x] host Kotlin QrAnalyzer type-check with CameraX/ZXing-shaped stubs
- [ ] real Android Gradle APK build in this container (SDK unavailable here)
- [ ] install/runtime matrix on physical Android 7→latest devices
See `TEST_REPORT.md` for exact test evidence and limitations. See `TEST_REPORT.md` and `TEST_RESULTS.txt` for executed evidence and limitations.
+103 -76
View File
@@ -1,99 +1,134 @@
# QFT · 超速二维码文件传输 v0.3.0-rc3 # QFT · 超速二维码文件传输 v0.4.0-rc2
Windows + Android 双向候选版。两个方向采用不同链路: Windows + Android 双向候选版。v0.4 的核心目标不是继续堆“4 码理论吞吐”,而是解决 Android 端实际识别慢的问题:**删除 2×2/4 通道,改成一个大二维码 + 动态 ROI 锁定 + 高频局部解码**。
- **Windows → Android:纯光学**。文件数据只经过 Windows 屏幕 → Android 摄像头;不使用 Wi‑Fi、蓝牙、局域网或互联网。 两个方向仍然采用不同链路:
- **Android → Windows:扫码本地直连**。Windows 选择保存目录并启动 QFT Direct 临时 Wi‑Fi/接收服务;Android 扫码后请求配网、自动发现电脑,然后并行分块上传。文件不经过外网。
> rc3 是性能/兼容性候选版。仓库内的协议、二维码、并行上传、UDP 发现、内存预算与 Kotlin 关键源文件测试已通过;真正的 Windows Wi‑Fi Direct 驱动、Windows 防火墙、60Hz 显示器与不同 Android 相机组合仍必须在真实设备上做验收,详见 `TEST_REPORT.md`。 - **Windows → Android:纯光学**。文件数据只经过 Windows 屏幕 → Android 摄像头;Wi‑Fi、蓝牙、局域网和互联网都不参与文件数据传输。
- **Android → Windows:扫码本地直连**。Windows 选择保存目录并启动 QFT Direct/LAN 接收服务;Android 扫码、配网、自动发现电脑,然后并行分块上传,不经过外网。
## v0.3.0-rc3 针对性优化 > rc2 已完成协议、图像合成解码、ROI、并行上传、UDP 发现、内存预算和关键 Kotlin 源码测试。当前生成环境没有真实 Windows 显示器、Android 相机或 Wi‑Fi Direct 适配器,因此物理 30/45/60 FPS 和真实扫码配网仍需在你的设备上跑 `VERIFY_WINDOWS_HOST.ps1` 后做最终验收;详见 `TEST_REPORT.md`。
### 1. Windows → Android:最高 60 FPS 显示目标 ## v0.4 光学链路改动
- Windows UI 支持 `1~60 FPS`,提供 15/30/60 与“极速预设”。 ### 单码替代 4 码
- 默认 **4 QR/页 + 60 FPS**,每次刷新最多承载 4 个独立 QFT1 数据帧。
- 单 QR payload 默认 900 B;理论原始文件载荷约 `900 × 4 × 60 = 216,000 B/s`(约 210.9 KiB/s),实际速度取决于显示器刷新率、Android 相机 FPS、曝光/滚动快门和识别率。
- Android 光学扫描采用 1280×720 分析帧、4 象限并行 ZXing 解码、`KEEP_ONLY_LATEST`、Y 平面直接读取且不再整帧旋转。
- Windows 预编码使用 Rayon 多核并行;GPU 纹理复用,不再每帧创建新的纹理对象。
- UI 动态显示目标 FPS、实际页面 FPS、理论载荷和 Android 实际“相机 FPS / 有效 QR/s”。
### 2. 文件与内存优化 4 码已从主链路彻底删除。原因是实际手机相机里,每个 QR 变小后会同时带来:
- Windows 光学源文件不做整文件 mmap;使用定位读取,避免大文件被整体映射/触碰进工作集。 - 每模块像素下降;
- 预编码缓存硬设计目标:整进程约 **≤ 1100 MiB**。 - finder 搜索次数增加;
- 4 QR / 960px 模式缓存最多 192 页,估算约 **675 MiB**;另为 UI、WGPU/GPU staging、线程栈、二维码临时对象和系统 I/O 留出余量。 - Android 同帧多次 ZXing 解码;
- Android → Windows 每个文件内部最高 **8 路并行**。 - 更高的摩尔纹/滚动快门敏感度;
- 分块根据文件大小自适应:小文件 4 MiB、中型 8 MiB、大文件 16 MiB;每个 worker 仅使用约 1 MiB 应用层 I/O buffer。 - Windows 理论 B/s 提升,但 Android “有效新帧/s”可能反而下降。
- Windows 端预分配 `.qftpart`,多个独立文件句柄按 offset 写入,完成后 SHA-256 校验并原子改名。
### 3. Android → Windows:连接速度/稳定性 v0.4 把全部屏幕和解码预算投入一个大 QR。
扫码二维码升级到更短的 `QFTPAIR2`: ### QFT2 + Base45 低密度帧
- 短字段 JSON + Base64URL。 活跃光学协议升级为 `QFT2:`:
- 配对 QR 使用中等级纠错,候选测试为 QR version 10。
- QFT Direct 二维码携带一个快速 endpoint hint,同时保留真实 Wi‑Fi 网关、UDP 发现与当前子网扫描作为 fallback。
- Android 配对扫描分辨率降到 640×480,优先 GlobalHistogram 快速路径;失败才周期性使用 HybridBinarizer。
- Android 连接 Wi‑Fi 后不立即假定网络可用,而是等待真实 IPv4/route。
- 电脑发现顺序:
1. QR endpoint hint;
2. `QFTDISC2` UDP 发现;
3. Android 真实 Wi‑Fi gateway;
4. 常见 Windows Direct 地址;
5. 当前实际子网最多 /24 的并发 fallback 扫描。
- 所有 HTTP 请求绑定到扫码建立的 `Network`,避免手机 4G/5G/其他 Wi‑Fi 抢路由。
- Android Manifest 同时启用 local cleartext network security config;QFTPAIR 解析器仍只允许 literal private/local IPv4 + 本次 session token。
### 4. Android 7 → 最新 - 二进制帧仍包含 session / sequence / total / payload / CRC32;
- 文本层使用 RFC 9285 Base45;
- Base45 字符集属于 QR 字母数字模式可编码范围;
- DATA payload 默认 **450 B**;
- QR 使用 L 级纠错和完整 4-module quiet zone;
- 合成测试中的 450 B DATA 帧为 **QR-L v15**,旧 QFT1/Base64 480 B 对照约为 v18;
- 60 显示帧/s 的理论纯 payload 为 `450 × 60 = 27,000 B/s ≈ 26.4 KiB/s`,真实速度取决于相机真实分析 FPS 和有效新帧率。
- `minSdk = 24`(Android 7.0)。 Android 仍保留 QFT1 解析用于旧发送端兼容。
- Android 10+:`WifiNetworkSpecifier` local-only 配网。
- Android 7~9:`WifiManager/WifiConfiguration` 兼容路径。
- Android 13+:`NEARBY_WIFI_DEVICES`。
- Android 7~12:位置权限兼容。
- Android 7~9 光学保存:`WRITE_EXTERNAL_STORAGE` + `Downloads/QFT`。
- Android 10+ 光学保存:MediaStore Downloads。
## Windows → Android 使用 ## Android 识别优化
1. Windows:进入 `电脑 → Android`。 ### Acquire → Lock → Expand → Reacquire
2. 选择文件。
3. 建议先用 `30 FPS / 4 码` 验证,再切 `60 FPS / 4 码`。
4. Android:`电脑 → 手机 → 开始光学接收`。
5. 让 2×2 QR 区域尽量完整占据手机取景框。
6. Android UI 会实时显示相机分析 FPS 和有效 QR/s;若识别偏低,靠近屏幕或把 Windows 降为 30 FPS。
7. 收齐后自动 SHA-256 校验并保存。
## Android → Windows 使用 扫描器状态机现在是:
1. Windows:`Android → 电脑`。 ```text
2. 选择接收文件夹。 搜索大二维码
3. 默认选择 `QFT Direct`。 ↓
4. 点击“启动接收并生成二维码”。 ZXing finder points
5. Windows 保持该页面开启。若 Windows Defender Firewall 首次询问网络访问,请允许 QFT 访问**专用网络**。 ↓
6. Android:`手机 → 电脑 → 扫码连接电脑`。 建立方形 ROI
7. 首次连接具体 QFT Direct AP 时,Android 系统可能要求确认该本地 Wi‑Fi。 ↓
8. App 自动完成 endpoint/UDP/gateway/subnet 发现,出现“已连接电脑”后选择文件并开始传输。 后续只复制/解码 ROI
↓
轻微移动:平滑跟随
↓
连续 miss:逐级扩大 ROI
↓
持续丢失:重新全局搜索
```
如果电脑没有可用 Wi‑Fi Direct 适配器,可切换 Windows 的“当前局域网”备用模式。 Android UI 会实时画出真正使用的锁定区域:
- 未锁定:白色搜索角标;
- 稳定锁定:绿色框 + 外围暗化;
- 临时 miss:黄色框;
- 锁定区域随 finder points 平滑移动,减少抖动;
- 锁定后周期性在 ROI 中心重新触发 AF/AE。
### 高频解码热路径
- `ImageAnalysis` 固定为 **640×480**;
- `STRATEGY_KEEP_ONLY_LATEST`,不追赶过时相机帧;
- Camera2Interop 从后摄实际公布的 AE FPS ranges 里选择最高不超过 60 的范围,并同时应用到 Preview/ImageAnalysis;若 OEM 拒绝该流组合,会自动回退相机默认 FPS,而不是让扫描器启动失败;
- 单个 `QRCodeReader`,无 4-reader 线程池;
- 锁定后只复制 Y 平面 ROI;
- `GrayFrameBuffer` 复用 grow-only `ByteArray`,降低 Android 7/8 GC;
- 常态使用 `GlobalHistogramBinarizer`;Hybrid 只在周期性 miss 时兜底;
- 重复显示帧虽然计入“成功解码”,但不再重复送入文件 assembler;UI 单独显示“解码/s”和“新帧/s”。
## Windows 光学 UI
Windows 光传页面已经改成“二维码优先”:
- 左侧控制区 / 右侧二维码区;
- 中间分隔条可拖动,压缩控制区后 QR 自动变大;
- “专注二维码”一键收起大部分控制 UI;
- QR 画面占比可调;
- FPS 5~60,快捷 30 / 45 / 60;
- 单个大 QR,NEAREST 纹理采样,避免插值模糊;
- 1024×1024 预编码画布,使用整数 module 像素和完整静区;
- 后台 Rayon 并行预编码未来帧,前台只复用一个 GPU TextureHandle。
推荐初次真机测试从 **30 FPS** 开始,看 Android 的“新帧/s”,再切 45、60。目标不是 Windows 数字最大,而是 Android **实际新帧/s 最大**。
## Android → Windows
v0.3 的稳定性优化继续保留:
- QFTPAIR2 紧凑配对 QR;
- QFT Direct 或当前局域网;
- Android 10+ `WifiNetworkSpecifier`;Android 7~9 legacy Wi-Fi;
- 扫码连接后 UDP `QFTDISC2` 快速发现;
- gateway / endpoint / 当前子网 fallback;
- HTTP 请求明确绑定扫码建立的 `Network`;
- 单文件最高 8 worker 并行;
- 4/8/16 MiB 自适应上传块;
- Windows positioned writes + `.qftpart` + SHA-256 + 最终 rename。
## Android 版本
- `minSdk = 24`,即 Android 7.0;
- Android 7~9:旧 Wi-Fi 与 Downloads 写入兼容;
- Android 10+:WifiNetworkSpecifier + MediaStore;
- Android 13+:NEARBY_WIFI_DEVICES 权限。
## 构建 ## 构建
### Windows ### Windows
需要 Rust stable MSVC + Visual C++ Build Tools / Windows SDK。
```powershell ```powershell
cd windows cd windows
cargo check cargo check
cargo test
cargo build --release cargo build --release
cargo run --release cargo run --release
``` ```
### Android ### Android
当前构建栈:compileSdk/targetSdk 35、minSdk 24、JDK 17。 JDK 17,compileSdk/targetSdk 35,minSdk 24:
```powershell ```powershell
cd android cd android
@@ -106,26 +141,18 @@ APK:
## 字体 ## 字体
Windows UI 优先读取: Windows UI 优先读取 `windows/assets/qft-ui.ttf`,也可用 `QFT_FONT_PATH` 指向你自己的中文 TTF。仓库不附带第三方字体文件。
`windows/assets/qft-ui.ttf` ## 自动验证
也可设置 `QFT_FONT_PATH` 指向支持中文的 TTF。项目不会分发第三方字体文件。
## 验证
开发侧测试:
```bash ```bash
python scripts/run_all_selftests.py python scripts/run_all_selftests.py
python scripts/optical_image_decode_selftest.py
python scripts/local_transfer_integration_selftest.py
``` ```
Windows 真机环境可运行根目录: Windows 主机建议直接:
```powershell ```powershell
.\VERIFY_WINDOWS_HOST.ps1 .\VERIFY_WINDOWS_HOST.ps1
``` ```
详细结果与尚未能在当前生成环境自动验证的硬件项目见 `TEST_REPORT.md`。 它会继续执行 Rust `cargo check/test/build` 和 Android Gradle 单测/APK 构建。物理相机/屏幕和 Wi‑Fi Direct 项目见 `TEST_REPORT.md`。
+158 -138
View File
@@ -1,182 +1,202 @@
# QFT v0.3.0-rc3 test report # QFT v0.4.0-rc2 test report
Date: 2026-08-10 Date: 2026-08-10
This report deliberately separates **tests actually executed in the current build environment** from **hardware acceptance that cannot be truthfully simulated here**. This report separates **tests actually executed in the current environment** from **physical hardware acceptance that cannot be simulated here**.
## What this RC changes
The rc2 optical path is deliberately simpler than v0.3:
- 2×2 / 4-channel QR removed;
- one large QR only;
- QFT2 + Base45 text layer;
- 450-byte DATA payload;
- Android 640×480 analysis;
- centered acquisition → finder-point ROI lock → progressive expansion → reacquire;
- reusable Y-plane buffer;
- GlobalHistogram fast hot path with sparse Hybrid fallback;
- duplicate displayed frames suppressed before the file assembler;
- dynamic lock overlay and movement-triggered AF/AE;
- Windows draggable split pane / focus-QR mode.
Android→Windows QFTPAIR2/discovery/parallel upload remains and is regression-tested.
## Executed and passed ## Executed and passed
### Optical protocol recovery ### 1. QFT2 optical loss recovery — PASS
Command: Command:
`python scripts/protocol_selftest.py` ```text
python scripts/protocol_selftest.py
```
Representative result from the final source:
```text
PASS QFT2/Base45 single-QR: 1200123 bytes, 2667 chunks,
22% frame loss, recovered in 6 rounds; QR-L v15 vs legacy Base64 v18,
12px/module@1024, text=722 chars, theoretical payload=26.4 KiB/s
```
Verified:
- Base45 known vectors;
- QFT2 magic/version/header;
- CRC32;
- 450 B DATA chunks;
- continuous replay after 22% synthetic whole-frame loss;
- exact file reconstruction;
- final SHA-256 equality;
- representative QFT2 QR density below the old QFT1/Base64 comparison.
Theoretical payload is `450 × 60 = 27,000 B/s`; it is not a claim of physical camera throughput.
### 2. Synthetic camera-frame decode and ROI — PASS
Command:
```text
python scripts/optical_image_decode_selftest.py
```
The test renders a 722-character QFT2/Base45 QR-L v15, places it into a 640×480 grayscale camera-like frame, applies 3° rotation and light Gaussian blur, then decodes both the full frame and a representative locked crop.
Typical final runs were approximately:
```text
full frame ≈ 4.2–4.7 ms/decode
locked ROI ≈ 2.8–2.9 ms/decode
ROI area ≈ 45–46% of frame
```
Both paths returned the exact QFT2 text. Timing varies by host and decoder cache state; this is a host-side directional benchmark, **not Android CameraX FPS**.
### 3. Single-channel / Android static guards — PASS
Commands:
```text
python scripts/android_compat_selftest.py
python scripts/single_channel_guard_selftest.py
```
Verified in the final source:
- `minSdk = 24`;
- no 2×2/4-lane Windows optical sender path;
- no four-reader Android optical decoder path;
- one large QFT2/Base45 QR;
- 450 B default DATA payload;
- 640×480 ImageAnalysis;
- `STRATEGY_KEEP_ONLY_LATEST`;
- Camera2Interop AE FPS request + no-explicit-FPS fallback when OEM binding rejects it;
- `QRCodeReader` only;
- ROI-only locked Y copy;
- grow-only reusable luma scratch buffer;
- lock smoothing / dynamic overlay / lock-centered refocus;
- QFT2/Base45 parsing + QFT1 legacy parsing;
- Android 7~9 and Android 10+ Wi-Fi branches;
- no `java.util.Base64` dependency in app source.
### 4. Host Kotlin QFT2/ROI runtime — PASS
`kotlin_host_smoke.py` compiled and executed the actual final:
- `Base45.kt`;
- `Base64Url.kt`;
- `Protocol.kt`;
- `LockRect.kt`.
Result: Result:
- 2,500,123-byte random file ```text
- 900-byte chunks PASS Kotlin QFT2/Base45 protocol + ROI lock smoothing
- 4 QR/page ```
- target 60 pages/s model
- synthetic 24% whole-page loss + 14% per-lane QR loss
- reconstructed exact original file in 9 rounds
- final SHA-256 identical
- representative frame: QR v25, ~3 rendered pixels/module at native 960px page
- theoretical raw file payload: ~210.9 KiB/s
**PASS** This test caught and fixed an earlier Kotlin expression-body compile error in `QftProtocol.parseText()` before packaging.
### Synthetic visual QR decode ### 5. Host Kotlin QrAnalyzer compile smoke — PASS
Command: The same test compiles the final `QrAnalyzer.kt`, `GrayFrame.kt`, `LockRect.kt` and `ScannerLockState.kt` against minimal CameraX/ZXing-shaped JVM stubs.
`python scripts/optical_image_decode_selftest.py`
Result in this environment:
- 4/4 high-density QFT optical QR symbols decoded from one 960×960 synthetic page using libzbar/pyzbar
- QFTPAIR2 QR-M decoded after synthetic 7° rotation plus light Gaussian blur
**PASS**
This proves generated QR geometry/data is decodable under a synthetic image path; it does **not** prove a particular monitor/camera can decode 60 physical refreshes per second.
### QFTPAIR2 size / QR density
Command:
`python scripts/pairing_selftest.py`
Result: Result:
- QFTPAIR2: 207 characters with one Direct-AP endpoint hint ```text
- older QFTPAIR1 comparison: 368 characters PASS Kotlin QrAnalyzer compile smoke with CameraX/ZXing-shaped stubs
- v2 size: 56.2% of v1 ```
- medium-error-correction QR: version 10
- encode/decode round-trip exact
**PASS** This checks Kotlin type/signature consistency of the ROI scanner without claiming it replaces a real Android SDK build.
### Parallel local-file chunk reconstruction ### 6. Android→Windows regression tests — PASS
Command: `run_all_selftests.py` also passed:
`python scripts/parallel_upload_selftest.py` - QFTPAIR2: 207 chars vs old 368-char test payload, QR-M v10 in the model;
- UDP discovery request/response token + port round trip;
- 8-worker parallel reconstruction of ~64 MiB;
- 8 MiB chunks / 1 MiB worker I/O;
- loopback UDP discovery + authenticated HTTP + out-of-order chunk upload;
- ~40 MiB final reconstruction with identical SHA-256.
Result: ### 7. Memory budget model — PASS
- ~64 MiB random file The guard models the Windows single-QR 1024×1024 RGBA pre-render queue:
- 8 MiB test chunks
- 8 worker threads
- 1 MiB worker I/O buffers
- out-of-order positioned writes
- final SHA-256 identical
**PASS** ```text
192 frames × ~4 MiB = 768 MiB managed cache
+ 96 MiB transient allowance
< 1100 MiB design ceiling
```
### End-to-end local protocol integration This is a design-budget check, not an OS-enforced RSS hard cap. GPU/runtime allocators can add platform-specific memory.
Command: ## Important implementation decisions validated during rc2
`python scripts/local_transfer_integration_selftest.py` ### QFT2 uses Result.text, not ZXing rawBytes
Result: The active path is Base45 text. Android reconstructs the QFT binary frame from `Result.text`. The code does not depend on ZXing `Result.rawBytes` representing the original byte-mode payload.
- QFTDISC2 UDP request/response ### Duplicate camera hits are not duplicate assembler work
- session-token authenticated `/qft/ping`
- Parallel-v2 init
- out-of-order chunk POSTs using 8 workers
- finish
- exact reconstructed file and SHA-256 match
**PASS** At 45/60 display FPS, a camera can observe the same displayed QR in multiple exposures. rc2 still counts every successful decode in diagnostics, but only a changed QFT2 text fingerprint is delivered to `SessionAssembler`.
### Standalone UDP discovery ### AF/AE does not run on a fixed periodic timer
Command: The scanner performs initial focus/metering, then re-meters after first lock or material ROI movement. A stationary locked QR does not force AF/AE every few seconds, reducing focus-pumping risk.
`python scripts/udp_discovery_selftest.py` ## Not executable in this environment
QFTDISC2 / QFTHERE2 token and port round-trip. The current generation environment does not contain the Windows MSVC Rust toolchain, Android SDK, a physical Android camera, a Windows display or a Windows Wi-Fi Direct adapter. Therefore the following are **not claimed as passed here**:
**PASS** 1. Windows `cargo check/test/build --release` for rc2.
2. Android Gradle `:app:testDebugUnitTest :app:assembleDebug` against the real Android SDK.
3. Actual 30/45/60 displayed FPS → CameraX/ZXing effective new-frame throughput.
4. Lock acquisition/reacquisition timing on Android 7 and different phone camera pipelines.
5. PreviewView overlay mapping on every OEM sensor/crop/rotation combination.
6. Real Windows QFT Direct adapter / driver / firewall behavior.
### Memory-budget model The package remains an **RC** until those physical checks pass.
Command: ## Required physical acceptance
`python scripts/memory_budget_selftest.py` Run:
Result: ```powershell
.\VERIFY_WINDOWS_HOST.ps1
```
- 4QR 960px pre-render page ≈ 3.5156 MiB as Color32 Then use a small optical file and record Android's UI values at Windows 30, 45 and 60 FPS:
- maximum cache page cap 192 → ≈ 675 MiB
- conservative extra transient test allowance remains below the 1100 MiB design ceiling
- whole source file is no longer memory-mapped
**PASS (design-budget test)** - camera FPS;
- successful decode/s;
- distinct new-frame/s;
- average decode ms;
- lock area percentage;
- time to first lock;
- time to reacquire after a small phone movement.
This is not an OS-level hard RSS limiter. GPU drivers, allocator fragmentation and platform runtime memory vary; the implementation intentionally leaves several hundred MiB headroom instead of allocating a full 1 GiB cache. Keep the Windows FPS setting that produces the highest **distinct new-frame/s**, not necessarily the highest display FPS.
### Android compatibility/static guards For file correctness, verify 100 KiB, 1 MiB and 10 MiB optical transfers by final SHA-256. For Android→Windows, repeat first-time Direct pairing, second pairing, Wi-Fi reconnect and LAN fallback.
Command:
`python scripts/android_compat_selftest.py`
Checked:
- minSdk 24
- API 29 modern/legacy Wi-Fi split
- Android 7~9 storage path
- Android <=12 location permission
- Android 13+ nearby-WiFi permission
- network security config for local HTTP
- gateway/directed-broadcast/subnet discovery fallbacks
- 8-worker upload
- 640×480 pairing scan + 1280×720 optical analysis
- KEEP_ONLY_LATEST
- no full-frame rotate in scanner hot path
- no `java.util.Base64` dependency in main Android source
**PASS**
### Kotlin source checks executed
Using `kotlinc-jvm 1.9.0` plus small Android/JSON stubs where necessary:
- `Base64Url.kt + Protocol.kt` runtime parser test: **PASS**
- `PairingProtocol.kt` syntax/type test: **PASS**
- `UploadClient.kt + PairingProtocol.kt` syntax/type test: **PASS**
- `GrayFrame.kt + QrAnalyzer.kt` syntax/type test: **PASS**
- `WifiConnector.kt` syntax/type test across the modern/legacy branches: **PASS**
These tests caught and fixed an earlier `ExecutorCompletionService.submit<String?>` source error before packaging rc3.
## Not executable in the current Linux build sandbox
The following are hardware/OS-specific and therefore are **not claimed as passed** here:
1. Windows `cargo check/build` against the Windows MSVC/WinRT target.
2. Actual `WiFiDirectAdvertisementPublisher` start on a Windows Wi-Fi adapter.
3. Windows Defender Firewall private-network approval behavior.
4. Android Gradle APK build against a local Android SDK in this sandbox.
5. Android 7/8/9/10/11/12/13/14/15/16+ install/runtime matrix.
6. Real monitor → real camera optical performance at 30/60Hz, different brightness, rolling shutter and autofocus conditions.
7. Real Wi-Fi Direct throughput across different NIC/phone vendors.
For those reasons **v0.3.0-rc3 remains an RC, not a final stable release**.
## Required physical acceptance before marking stable
Run `VERIFY_WINDOWS_HOST.ps1`, then at minimum:
- Windows 10/11 + Android 7/9/10/13/latest available devices.
- Optical files: 10 KiB, 1 MiB, 10 MiB at 30 FPS and 60 FPS.
- Verify Android UI actual camera FPS / QR/s and final SHA-256.
- Android→Windows QFT Direct: first-time pairing, repeat pairing, reconnect after Wi-Fi loss.
- Test with Windows Firewall prompt accepted and with “current LAN” fallback.
- Upload 10 MiB, 500 MiB, and >2 GiB files; verify final SHA-256 and memory usage.
- Observe Windows working set during optical 60 FPS; if host-specific RSS exceeds 1.1 GiB, reduce the pre-encode cache slider (default 384 MiB) and record the device/driver combination.
Only after this matrix is passed should the RC label be removed.
+14 -18
View File
@@ -1,8 +1,10 @@
QFT v0.3.0-rc3 test execution log QFT v0.4.0-rc2 test results
UTC 2026-08-10 06:48:06 UTC 2026-08-10T08:45:56Z
== protocol_selftest.py == == protocol_selftest.py ==
PASS optical: 2500123 bytes, 2778 chunks, 4 QR/page @ 60 FPS, 24% page loss + 14% lane loss, recovered in 9 rounds; QR v25, 3px/module, frame chars=1243, theoretical payload=210.9 KiB/s PASS QFT2/Base45 single-QR: 1200123 bytes, 2667 chunks, 22% frame loss, recovered in 6 rounds; QR-L v15 vs legacy Base64 v18, 12px/module@1024, text=722 chars, theoretical payload=26.4 KiB/s
== optical_image_decode_selftest.py ==
PASS synthetic QFT2 lock: QR-L v15, 722 chars; full=4.1ms, lockedROI=2.8ms, ROI area=45.3%
== pairing_selftest.py == == pairing_selftest.py ==
PASS pairing: QFTPAIR2=207 chars vs v1=368 chars (56.2%), QR-M version=10 PASS pairing: QFTPAIR2=207 chars vs v1=368 chars (56.2%), QR-M version=10
== parallel_upload_selftest.py == == parallel_upload_selftest.py ==
@@ -10,20 +12,14 @@ PASS parallel upload: 67121209 bytes, 8 MiB chunks, 8 workers, 1 MiB worker I/O,
== udp_discovery_selftest.py == == udp_discovery_selftest.py ==
PASS UDP discovery: request/response token+port round-trip from 127.0.0.1 PASS UDP discovery: request/response token+port round-trip from 127.0.0.1
== local_transfer_integration_selftest.py == == local_transfer_integration_selftest.py ==
PASS loopback Parallel v2 integration: UDP discovery + HTTP auth + 6 out-of-order chunks / 8 workers; 41955385 bytes SHA-256 identical in 0.22s PASS loopback Parallel v2 integration: UDP discovery + HTTP auth + 6 out-of-order chunks / 8 workers; 41955385 bytes SHA-256 identical in 0.19s
== memory_budget_selftest.py == == memory_budget_selftest.py ==
PASS memory budget: 4QR cache=192 pages/675.0 MiB; 1QR cache=192 pages/423.0 MiB; hard design ceiling=1100 MiB PASS memory budget: single-QR cache=192 frames/768.0 MiB + 96 MiB transient allowance < 1100 MiB
== android_compat_selftest.py == == android_compat_selftest.py ==
PASS Android compatibility/static guards: minSdk24, API29 split, legacy storage/location, Android13 nearby-WiFi, cleartext local config, subnet fallback, fast scanner paths PASS Android static guards: API24+, 640x480 single-QR ROI, reusable luma buffer, QFT2/Base45 text parse, dynamic lock/refocus, Camera2 FPS request, legacy/new Wi-Fi compatibility
ALL CORE PYTHON SELFTESTS PASSED == single_channel_guard_selftest.py ==
PASS synthetic QR decode: 4/4 optical QR v25 decoded from 960px page in 48.3 ms; QFTPAIR2 QR-M v10 decoded after 7deg rotate+blur in 1.7 ms PASS single-channel guard: one large QFT2/Base45 QR, 450B chunks, no 2x2/4-lane path, Android locked-ROI text decode only
== kotlin_host_smoke.py ==
Kotlin runtime: Base64Url + QFT1 PASS Kotlin QFT2/Base45 protocol + ROI lock smoothing
PASS Kotlin Base64Url + QFT1 parser PASS Kotlin QrAnalyzer compile smoke with CameraX/ZXing-shaped stubs
ALL HOST SELFTESTS PASSED
Kotlin syntax: PairingProtocol + UploadClient
PASS Kotlin syntax: PairingProtocol.kt + UploadClient.kt
Kotlin syntax: GrayFrame + QrAnalyzer
PASS Kotlin syntax: GrayFrame.kt + QrAnalyzer.kt
Kotlin syntax: WifiConnector
PASS Kotlin syntax: WifiConnector.kt
+9 -3
View File
@@ -1,20 +1,26 @@
$ErrorActionPreference = 'Stop' $ErrorActionPreference = 'Stop'
$Root = Split-Path -Parent $MyInvocation.MyCommand.Path $Root = Split-Path -Parent $MyInvocation.MyCommand.Path
Write-Host "== QFT v0.3.0-rc3 Windows host verification ==" -ForegroundColor Cyan Write-Host "== QFT v0.4.0-rc2 Windows host verification ==" -ForegroundColor Cyan
if (Get-Command python -ErrorAction SilentlyContinue) { if (Get-Command python -ErrorAction SilentlyContinue) {
Write-Host "[1/4] Core protocol/selftests" Write-Host "[1/4] Core protocol/selftests"
& python "$Root\scripts\run_all_selftests.py" & python "$Root\scripts\run_all_selftests.py"
if ($LASTEXITCODE -ne 0) {
Write-Host "If Python reports missing qrcode/cv2, run: python -m pip install -r `"$Root\scripts\requirements-test.txt`"" -ForegroundColor Yellow
throw "repository Python selftests failed"
}
} else { } else {
Write-Warning "python not found; skipping repository Python selftests" Write-Warning "python not found; skipping repository Python selftests"
} }
Write-Host "[2/4] Windows Rust compile" Write-Host "[2/4] Windows Rust compile/test/release"
Push-Location "$Root\windows" Push-Location "$Root\windows"
try { try {
& cargo check & cargo check
if ($LASTEXITCODE -ne 0) { throw "cargo check failed" } if ($LASTEXITCODE -ne 0) { throw "cargo check failed" }
& cargo test
if ($LASTEXITCODE -ne 0) { throw "cargo test failed" }
& cargo build --release & cargo build --release
if ($LASTEXITCODE -ne 0) { throw "cargo build --release failed" } if ($LASTEXITCODE -ne 0) { throw "cargo build --release failed" }
} finally { Pop-Location } } finally { Pop-Location }
@@ -33,5 +39,5 @@ try {
Write-Host "[4/4] Artifact locations" -ForegroundColor Cyan Write-Host "[4/4] Artifact locations" -ForegroundColor Cyan
Write-Host "Windows EXE: $Root\windows\target\release\qft-windows.exe" Write-Host "Windows EXE: $Root\windows\target\release\qft-windows.exe"
Write-Host "Android APK: $Root\android\app\build\outputs\apk\debug\app-debug.apk" Write-Host "Android APK: $Root\android\app\build\outputs\apk\debug\app-debug.apk"
Write-Host "\nHOST BUILD VERIFICATION PASSED" -ForegroundColor Green Write-Host "`nHOST BUILD VERIFICATION PASSED" -ForegroundColor Green
Write-Host "Next: perform the physical display/camera and Wi-Fi Direct acceptance matrix in TEST_REPORT.md." Write-Host "Next: perform the physical display/camera and Wi-Fi Direct acceptance matrix in TEST_REPORT.md."
+2 -2
View File
@@ -12,8 +12,8 @@ android {
applicationId = "com.qft.optical" applicationId = "com.qft.optical"
minSdk = 24 minSdk = 24
targetSdk = 35 targetSdk = 35
versionCode = 8 versionCode = 10
versionName = "0.3.0-rc3" versionName = "0.4.0-rc2"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
} }
@@ -0,0 +1,41 @@
package com.qft.optical
/** RFC 9285 Base45 decoder. Alphabet maps directly to QR alphanumeric mode. */
object Base45 {
private const val ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"
private val reverse = IntArray(128) { -1 }.apply {
ALPHABET.forEachIndexed { index, c -> this[c.code] = index }
}
fun decode(text: String): ByteArray? {
if (text.isEmpty()) return ByteArray(0)
if (text.length % 3 == 1) return null
val out = ByteArray((text.length / 3) * 2 + if (text.length % 3 == 2) 1 else 0)
var i = 0
var o = 0
while (i + 2 < text.length) {
val a = value(text[i]) ?: return null
val b = value(text[i + 1]) ?: return null
val c = value(text[i + 2]) ?: return null
val n = a + b * 45 + c * 45 * 45
if (n > 0xFFFF) return null
out[o++] = (n / 256).toByte()
out[o++] = (n % 256).toByte()
i += 3
}
if (i < text.length) {
val a = value(text[i]) ?: return null
val b = value(text[i + 1]) ?: return null
val n = a + b * 45
if (n > 0xFF) return null
out[o++] = n.toByte()
}
return if (o == out.size) out else out.copyOf(o)
}
private fun value(c: Char): Int? {
if (c.code >= reverse.size) return null
val v = reverse[c.code]
return if (v >= 0) v else null
}
}
@@ -2,42 +2,63 @@ package com.qft.optical
import androidx.camera.core.ImageProxy import androidx.camera.core.ImageProxy
/** /** Dense Y-plane crop used by ZXing. */
* Copies only the Y plane. data class GrayFrame(
* val width: Int,
* QFT deliberately keeps the camera buffer in sensor orientation. QR finder val height: Int,
* patterns are rotation independent, and the optical 2x2 layout is still a 2x2 val luma: ByteArray,
* layout after a 90° rotation. Avoiding a second full-frame rotate/copy removes val originX: Int,
* almost half of the memory traffic in the scanner hot path on portrait phones. val originY: Int,
*/ val fullWidth: Int,
data class GrayFrame(val width: Int, val height: Int, val luma: ByteArray) { val fullHeight: Int,
companion object { val rotationDegrees: Int,
fun from(image: ImageProxy): GrayFrame { )
val plane = image.planes[0]
val src = plane.buffer.duplicate()
val rowStride = plane.rowStride
val pixelStride = plane.pixelStride
val w = image.width
val h = image.height
val raw = ByteArray(w * h)
if (pixelStride == 1 && rowStride == w) { /**
src.position(0) * Reusable luminance scratch buffer. ImageAnalysis calls the analyzer serially,
src.get(raw, 0, raw.size) * so one grow-only byte array is enough for the full hot path. This avoids a
} else if (pixelStride == 1) { * ByteArray allocation for every camera frame and materially reduces GC on
for (y in 0 until h) { * Android 7/8 class devices.
src.position(y * rowStride) */
src.get(raw, y * w, w) class GrayFrameBuffer {
} private var scratch = ByteArray(0)
} else {
for (y in 0 until h) { fun capture(image: ImageProxy, requested: LockRect? = null): GrayFrame {
val rowStart = y * rowStride val plane = image.planes[0]
for (x in 0 until w) { val src = plane.buffer.duplicate()
raw[y * w + x] = src.get(rowStart + x * pixelStride) val rowStride = plane.rowStride
} val pixelStride = plane.pixelStride
val fullW = image.width
val fullH = image.height
val crop = (requested ?: LockRect(0, 0, fullW, fullH)).clamp(fullW, fullH)
val needed = crop.width * crop.height
if (scratch.size < needed) scratch = ByteArray(needed)
if (pixelStride == 1) {
for (y in 0 until crop.height) {
val sourceOffset = (crop.top + y) * rowStride + crop.left
src.position(sourceOffset)
src.get(scratch, y * crop.width, crop.width)
}
} else {
for (y in 0 until crop.height) {
val rowStart = (crop.top + y) * rowStride
val dst = y * crop.width
for (x in 0 until crop.width) {
scratch[dst + x] = src.get(rowStart + (crop.left + x) * pixelStride)
} }
} }
return GrayFrame(w, h, raw)
} }
return GrayFrame(
width = crop.width,
height = crop.height,
luma = scratch,
originX = crop.left,
originY = crop.top,
fullWidth = fullW,
fullHeight = fullH,
rotationDegrees = image.imageInfo.rotationDegrees,
)
} }
} }
@@ -0,0 +1,100 @@
package com.qft.optical
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
/**
* Pure geometry used by the optical scanner. Kept Android-free so it can be
* unit tested on the host JVM.
*/
data class LockRect(
val left: Int,
val top: Int,
val width: Int,
val height: Int,
) {
val right: Int get() = left + width
val bottom: Int get() = top + height
fun clamp(frameWidth: Int, frameHeight: Int): LockRect {
val l = left.coerceIn(0, (frameWidth - 1).coerceAtLeast(0))
val t = top.coerceIn(0, (frameHeight - 1).coerceAtLeast(0))
val r = right.coerceIn(l + 1, frameWidth.coerceAtLeast(l + 1))
val b = bottom.coerceIn(t + 1, frameHeight.coerceAtLeast(t + 1))
return LockRect(l, t, r - l, b - t)
}
fun expand(frameWidth: Int, frameHeight: Int, factor: Float): LockRect {
val f = factor.coerceAtLeast(1f)
val cx = left + width / 2f
val cy = top + height / 2f
val w = (width * f).toInt().coerceAtLeast(96)
val h = (height * f).toInt().coerceAtLeast(96)
return LockRect((cx - w / 2f).toInt(), (cy - h / 2f).toInt(), w, h)
.clamp(frameWidth, frameHeight)
}
fun smoothToward(target: LockRect, alpha: Float): LockRect {
val a = alpha.coerceIn(0f, 1f)
fun mix(x: Int, y: Int) = (x + (y - x) * a).toInt()
return LockRect(
mix(left, target.left),
mix(top, target.top),
mix(width, target.width),
mix(height, target.height),
)
}
fun areaFraction(frameWidth: Int, frameHeight: Int): Float {
val total = frameWidth.toLong() * frameHeight.toLong()
if (total <= 0L) return 1f
return ((width.toLong() * height.toLong()).toDouble() / total.toDouble()).toFloat()
}
fun materiallyDiffers(other: LockRect?): Boolean {
if (other == null) return true
val d = abs(left - other.left) + abs(top - other.top) +
abs(width - other.width) + abs(height - other.height)
return d > max(width, height) / 18
}
companion object {
/**
* ZXing normally returns the finder-pattern centers. Their bounding box
* is smaller than the full symbol, so enlarge to roughly 1.28x and force
* a square ROI. This keeps the complete quiet zone while discarding most
* of the camera frame after lock-on.
*/
fun fromPoints(
points: List<Pair<Float, Float>>,
frameWidth: Int,
frameHeight: Int,
): LockRect? {
if (points.size < 3 || frameWidth < 2 || frameHeight < 2) return null
val minX = points.minOf { it.first }
val maxX = points.maxOf { it.first }
val minY = points.minOf { it.second }
val maxY = points.maxOf { it.second }
val span = max(maxX - minX, maxY - minY)
if (span < 24f) return null
val side = (span * 1.28f).toInt().coerceAtLeast(128)
val cx = (minX + maxX) * 0.5f
val cy = (minY + maxY) * 0.5f
return LockRect(
(cx - side / 2f).toInt(),
(cy - side / 2f).toInt(),
side,
side,
).clamp(frameWidth, frameHeight)
}
fun centeredSearch(frameWidth: Int, frameHeight: Int, fraction: Float = 0.92f): LockRect {
val f = fraction.coerceIn(0.5f, 1f)
val w = (frameWidth * f).toInt().coerceAtLeast(1)
val h = (frameHeight * f).toInt().coerceAtLeast(1)
return LockRect((frameWidth - w) / 2, (frameHeight - h) / 2, w, h)
}
}
}
@@ -5,9 +5,13 @@ import android.content.pm.PackageManager
import android.content.res.ColorStateList import android.content.res.ColorStateList
import android.graphics.Color import android.graphics.Color
import android.graphics.drawable.GradientDrawable import android.graphics.drawable.GradientDrawable
import android.hardware.camera2.CameraCharacteristics
import android.hardware.camera2.CameraManager
import android.hardware.camera2.CaptureRequest
import android.net.Network import android.net.Network
import android.os.Build import android.os.Build
import android.os.Bundle import android.os.Bundle
import android.util.Range
import android.util.Size import android.util.Size
import android.view.Gravity import android.view.Gravity
import android.view.ViewGroup import android.view.ViewGroup
@@ -19,6 +23,10 @@ import android.widget.ScrollView
import android.widget.TextView import android.widget.TextView
import androidx.activity.ComponentActivity import androidx.activity.ComponentActivity
import androidx.activity.result.contract.ActivityResultContracts import androidx.activity.result.contract.ActivityResultContracts
import androidx.annotation.OptIn
import androidx.camera.camera2.interop.Camera2Interop
import androidx.camera.camera2.interop.ExperimentalCamera2Interop
import androidx.camera.core.Camera
import androidx.camera.core.CameraSelector import androidx.camera.core.CameraSelector
import androidx.camera.core.FocusMeteringAction import androidx.camera.core.FocusMeteringAction
import androidx.camera.core.ImageAnalysis import androidx.camera.core.ImageAnalysis
@@ -39,8 +47,14 @@ class MainActivity : ComponentActivity() {
private lateinit var assembler: SessionAssembler private lateinit var assembler: SessionAssembler
private var cameraProvider: ProcessCameraProvider? = null private var cameraProvider: ProcessCameraProvider? = null
private var activeCamera: Camera? = null
private var lastLockFocusAt = 0L
private var lastLockFocusX = -1f
private var lastLockFocusY = -1f
private var currentAnalyzer: QrAnalyzer? = null private var currentAnalyzer: QrAnalyzer? = null
private var qrLockOverlay: QrLockOverlay? = null
private var scannerStatsText: TextView? = null private var scannerStatsText: TextView? = null
private var scannerLockText: TextView? = null
private var scannerMode = ScannerMode.NONE private var scannerMode = ScannerMode.NONE
private var pendingScannerMode = ScannerMode.NONE private var pendingScannerMode = ScannerMode.NONE
private val pairConsumed = AtomicBoolean(false) private val pairConsumed = AtomicBoolean(false)
@@ -126,8 +140,8 @@ class MainActivity : ComponentActivity() {
root.addView(modeCard( root.addView(modeCard(
title = "电脑 → 手机", title = "电脑 → 手机",
badge = "光学零网络 · 4码并行 · 60FPS显示", badge = "光学零网络 · 单码锁定 · QFT2低密度字母数字QR · 最高60FPS显示",
body = "手机摄像头连续读取电脑动态二维码。Wi-Fi、蓝牙、局域网和互联网都不参与文件数据传输。", body = "手机先搜索并锁定一个大二维码,之后只分析锁定区域。QFT2 使用 Base45 让 QR 保持字母数字模式并降低模块密度;Wi-Fi、蓝牙、局域网和互联网都不参与文件数据传输。",
buttonLabel = "开始光学接收", buttonLabel = "开始光学接收",
) { requestScanner(ScannerMode.OPTICAL) }) ) { requestScanner(ScannerMode.OPTICAL) })
root.addView(space(16)) root.addView(space(16))
@@ -139,7 +153,7 @@ class MainActivity : ComponentActivity() {
) { requestScanner(ScannerMode.PAIR) }) ) { requestScanner(ScannerMode.PAIR) })
root.addView(space(22)) root.addView(space(22))
root.addView(text("本机设备:$receiverDeviceLabel", 13f, MUTED)) root.addView(text("本机设备:$receiverDeviceLabel", 13f, MUTED))
root.addView(text("QFT v0.3.0-rc3 · Android 7+ 到最新", 12f, MUTED)) root.addView(text("QFT v0.4.0-rc2 · Android 7+ 到最新", 12f, MUTED))
setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) }) setContentView(ScrollView(this).apply { setBackgroundColor(BG); addView(root) })
} }
@@ -158,6 +172,7 @@ class MainActivity : ComponentActivity() {
} }
} }
@OptIn(markerClass = [ExperimentalCamera2Interop::class])
private fun startScanner(mode: ScannerMode) { private fun startScanner(mode: ScannerMode) {
scannerMode = mode scannerMode = mode
pairConsumed.set(false) pairConsumed.set(false)
@@ -166,19 +181,30 @@ class MainActivity : ComponentActivity() {
future.addListener({ future.addListener({
val provider = future.get() val provider = future.get()
cameraProvider = provider cameraProvider = provider
val preview = Preview.Builder().build().also { it.surfaceProvider = previewView.surfaceProvider } val requestedFps = chooseCameraFpsRange()
val profile = if (mode == ScannerMode.PAIR) QrAnalyzer.Profile.PAIR_FAST else QrAnalyzer.Profile.OPTICAL_MULTI
// CameraX 1.4.x ImageAnalysis.Builder has no public setTargetFrameRate().
// Apply a range actually advertised by the selected back camera via
// Camera2Interop to both bound use cases.
val previewBuilder = Preview.Builder()
Camera2Interop.Extender(previewBuilder).setCaptureRequestOption(
CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,
requestedFps,
)
val preview = previewBuilder.build().also { it.surfaceProvider = previewView.surfaceProvider }
val profile = if (mode == ScannerMode.PAIR) QrAnalyzer.Profile.PAIR_FAST else QrAnalyzer.Profile.OPTICAL_LOCKED
currentAnalyzer?.close() currentAnalyzer?.close()
val analyzer = QrAnalyzer( val analyzer = QrAnalyzer(
profile = profile, profile = profile,
onTexts = { values -> onCode = { code ->
when (scannerMode) { when (scannerMode) {
ScannerMode.OPTICAL -> values.forEach(assembler::acceptText) ScannerMode.OPTICAL -> assembler.acceptText(code.text)
ScannerMode.PAIR -> values.firstOrNull { PairingProtocol.isPairingText(it) }?.let(::acceptPairCode) ScannerMode.PAIR -> if (PairingProtocol.isPairingText(code.text)) acceptPairCode(code.text)
ScannerMode.NONE -> Unit ScannerMode.NONE -> Unit
} }
}, },
onStats = { cameraFps, decodedFps -> onStats = { cameraFps, decodedFps, distinctFps, decodeMs ->
runOnUiThread { runOnUiThread {
val quality = when (mode) { val quality = when (mode) {
ScannerMode.PAIR -> when { ScannerMode.PAIR -> when {
@@ -187,38 +213,152 @@ class MainActivity : ComponentActivity() {
else -> "相机帧率偏低" to WARNING else -> "相机帧率偏低" to WARNING
} }
ScannerMode.OPTICAL -> when { ScannerMode.OPTICAL -> when {
decodedFps >= cameraFps.coerceAtLeast(1.0) * 1.5 -> "光学链路稳定" to SUCCESS distinctFps >= 18.0 -> "新帧吞吐良好" to SUCCESS
decodedFps >= 5.0 -> "可接收 · 建议保持手机稳定" to ACCENT distinctFps >= 8.0 -> "可接收 · 继续保持二维码稳定" to ACCENT
else -> "识别偏低 · 靠近屏幕或降低 Windows FPS" to WARNING decodedFps >= 8.0 -> "重复帧较多 · 尝试 Windows 30/45 FPS" to WARNING
else -> "识别偏低 · 放大 Windows 二维码或降到 30 FPS" to WARNING
} }
ScannerMode.NONE -> "空闲" to MUTED ScannerMode.NONE -> "空闲" to MUTED
} }
scannerStatsText?.text = "%s · 相机 %.1f FPS · 有效 QR %.1f/s".format(quality.first, cameraFps, decodedFps) scannerStatsText?.text = if (mode == ScannerMode.OPTICAL) {
"%s · 相机 %.1f FPS · 解码 %.1f/s · 新帧 %.1f/s · %.1fms/次".format(
quality.first, cameraFps, decodedFps, distinctFps, decodeMs
)
} else {
"%s · 相机 %.1f FPS · 解码 %.1f/s · %.1fms/次".format(quality.first, cameraFps, decodedFps, decodeMs)
}
scannerStatsText?.setTextColor(quality.second) scannerStatsText?.setTextColor(quality.second)
} }
}, },
onLock = { lock ->
runOnUiThread {
qrLockOverlay?.update(lock)
if (mode == ScannerMode.OPTICAL) {
if (lock.locked && lock.misses == 0) maybeRefocusLockedQr()
scannerLockText?.text = if (lock.locked) {
val lockHint = if (lock.misses == 0) "稳定锁定" else "保持锁定 · miss ${lock.misses}"
"$lockHint · 仅分析 ${(lock.searchAreaFraction * 100f).toInt().coerceIn(1, 100)}% 画面"
} else {
"区域锁定:搜索中 · 让单个大二维码占取景框 50% 以上"
}
scannerLockText?.setTextColor(
if (!lock.locked) ACCENT else if (lock.misses == 0) SUCCESS else WARNING
)
}
}
},
) )
currentAnalyzer = analyzer currentAnalyzer = analyzer
val targetSize = if (mode == ScannerMode.PAIR) Size(640, 480) else Size(1280, 720)
val analysis = ImageAnalysis.Builder() // v0.4 single large QR is intentionally analyzed at 640x480. With the
// QR occupying most of the view this still leaves several camera
// pixels/module, while substantially reducing Y-copy + ZXing work.
val targetSize = Size(640, 480)
val analysisBuilder = ImageAnalysis.Builder()
.setTargetResolution(targetSize) .setTargetResolution(targetSize)
.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST) .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
.build() Camera2Interop.Extender(analysisBuilder).setCaptureRequestOption(
.also { it.setAnalyzer(cameraExecutor, analyzer) } CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,
requestedFps,
)
val analysis = analysisBuilder.build().also { it.setAnalyzer(cameraExecutor, analyzer) }
provider.unbindAll() provider.unbindAll()
val camera = provider.bindToLifecycle(this, CameraSelector.DEFAULT_BACK_CAMERA, preview, analysis) val camera = try {
// Screen QR benefits from an immediate center AF/AE metering pass. provider.bindToLifecycle(this, CameraSelector.DEFAULT_BACK_CAMERA, preview, analysis).also {
try { scannerStatsText?.text = "相机请求 ${requestedFps.lower}~${requestedFps.upper} FPS · 等待首帧…"
val point = previewView.meteringPointFactory.createPoint(0.5f, 0.5f) }
val action = FocusMeteringAction.Builder( } catch (_: Exception) {
point, // Some old/OEM devices advertise a Camera2 FPS range that is not
FocusMeteringAction.FLAG_AF or FocusMeteringAction.FLAG_AE, // accepted together with the selected CameraX stream combination.
).setAutoCancelDuration(5, TimeUnit.SECONDS).build() // Retry without the explicit AE range rather than failing scanner
camera.cameraControl.startFocusAndMetering(action) // startup; KEEP_ONLY_LATEST + ROI still provides the fast path.
} catch (_: Exception) {} provider.unbindAll()
val fallbackPreview = Preview.Builder().build().also {
it.surfaceProvider = previewView.surfaceProvider
}
val fallbackAnalysis = ImageAnalysis.Builder()
.setTargetResolution(targetSize)
.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
.build().also { it.setAnalyzer(cameraExecutor, analyzer) }
scannerStatsText?.text = "设备拒绝显式高帧率请求 · 已回退相机自动 FPS · 等待首帧…"
provider.bindToLifecycle(
this,
CameraSelector.DEFAULT_BACK_CAMERA,
fallbackPreview,
fallbackAnalysis,
)
}
activeCamera = camera
previewView.post {
if (previewView.width <= 0 || previewView.height <= 0) return@post
try {
val point = previewView.meteringPointFactory.createPoint(
previewView.width * 0.5f,
previewView.height * 0.5f,
)
val action = FocusMeteringAction.Builder(
point,
FocusMeteringAction.FLAG_AF or FocusMeteringAction.FLAG_AE,
).setAutoCancelDuration(5, TimeUnit.SECONDS).build()
camera.cameraControl.startFocusAndMetering(action)
} catch (_: Exception) {}
}
}, mainExecutor) }, mainExecutor)
} }
private fun maybeRefocusLockedQr() {
val camera = activeCamera ?: return
val center = qrLockOverlay?.lockedCenterInView() ?: return
if (previewView.width <= 0 || previewView.height <= 0) return
// Do not force an AF/AE cycle every few seconds while the phone is
// stationary: focus pumping can temporarily destroy QR contrast.
// Re-meter only on the first lock or after the locked region moved
// materially in the preview.
val threshold = minOf(previewView.width, previewView.height) * 0.10f
val dx = center.x - lastLockFocusX
val dy = center.y - lastLockFocusY
val moved = lastLockFocusX < 0f || dx * dx + dy * dy >= threshold * threshold
if (!moved) return
val now = android.os.SystemClock.elapsedRealtime()
if (now - lastLockFocusAt < 1200L) return
lastLockFocusAt = now
lastLockFocusX = center.x
lastLockFocusY = center.y
try {
val point = previewView.meteringPointFactory.createPoint(center.x, center.y)
val action = FocusMeteringAction.Builder(
point,
FocusMeteringAction.FLAG_AF or FocusMeteringAction.FLAG_AE,
).setAutoCancelDuration(2, TimeUnit.SECONDS).build()
camera.cameraControl.startFocusAndMetering(action)
} catch (_: Exception) {}
}
private fun chooseCameraFpsRange(): Range<Int> {
return try {
val manager = getSystemService(android.content.Context.CAMERA_SERVICE) as CameraManager
val characteristics = manager.cameraIdList
.asSequence()
.map { manager.getCameraCharacteristics(it) }
.firstOrNull { it.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_BACK }
val ranges = characteristics?.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES)
?.toList().orEmpty()
ranges
.filter { it.upper <= 60 && it.lower <= 30 }
.maxWithOrNull(compareBy<Range<Int>> { it.upper }.thenBy { it.lower })
?: ranges.filter { it.upper <= 60 }
.maxWithOrNull(compareBy<Range<Int>> { it.upper }.thenBy { it.lower })
?: ranges.maxWithOrNull(compareBy<Range<Int>> { it.upper }.thenBy { it.lower })
?: Range(30, 30)
} catch (_: Exception) {
Range(30, 30)
}
}
private fun buildCameraUi(mode: ScannerMode): FrameLayout { private fun buildCameraUi(mode: ScannerMode): FrameLayout {
val root = FrameLayout(this).apply { setBackgroundColor(Color.BLACK) } val root = FrameLayout(this).apply { setBackgroundColor(Color.BLACK) }
previewView = PreviewView(this).apply { previewView = PreviewView(this).apply {
@@ -226,6 +366,8 @@ class MainActivity : ComponentActivity() {
scaleType = PreviewView.ScaleType.FILL_CENTER scaleType = PreviewView.ScaleType.FILL_CENTER
} }
root.addView(previewView, FrameLayout.LayoutParams(-1, -1)) root.addView(previewView, FrameLayout.LayoutParams(-1, -1))
qrLockOverlay = QrLockOverlay(this)
root.addView(qrLockOverlay, FrameLayout.LayoutParams(-1, -1))
val top = LinearLayout(this).apply { val top = LinearLayout(this).apply {
orientation = LinearLayout.HORIZONTAL orientation = LinearLayout.HORIZONTAL
@@ -245,20 +387,25 @@ class MainActivity : ComponentActivity() {
background = rounded(0xE80C0E12.toInt(), 18) background = rounded(0xE80C0E12.toInt(), 18)
} }
deviceText = text( deviceText = text(
if (mode == ScannerMode.OPTICAL) "接收设备:$receiverDeviceLabel\n发送设备:等待 QFT1 MANIFEST…" if (mode == ScannerMode.OPTICAL) "接收设备:$receiverDeviceLabel\n发送设备:等待 QFT2 MANIFEST…"
else "目标:等待 QFTPAIR2 配对二维码", else "目标:等待 QFTPAIR2 配对二维码",
14f, Color.WHITE 14f, Color.WHITE
) )
statusText = text( statusText = text(
if (mode == ScannerMode.OPTICAL) "把电脑动态二维码完整放进取景框" if (mode == ScannerMode.OPTICAL) "让电脑的单个大二维码占取景框 50% 以上,识别后会自动锁定区域"
else "扫描 Windows“手机传电脑”页面上的二维码", else "扫描 Windows“手机传电脑”页面上的二维码",
14f, MUTED 14f, MUTED
) )
progress = ProgressBar(this, null, android.R.attr.progressBarStyleHorizontal).apply { max = 1000; progress = 0 } progress = ProgressBar(this, null, android.R.attr.progressBarStyleHorizontal).apply { max = 1000; progress = 0 }
panel.addView(deviceText) panel.addView(deviceText)
panel.addView(statusText, matchWrap(top = 7)) panel.addView(statusText, matchWrap(top = 7))
scannerLockText = text(
if (mode == ScannerMode.OPTICAL) "区域锁定:搜索中" else "配对识别:快速模式",
12f, ACCENT
)
panel.addView(scannerLockText, matchWrap(top = 6))
scannerStatsText = text("相机分析:等待首帧…", 12f, ACCENT) scannerStatsText = text("相机分析:等待首帧…", 12f, ACCENT)
panel.addView(scannerStatsText, matchWrap(top = 6)) panel.addView(scannerStatsText, matchWrap(top = 4))
panel.addView(progress, LinearLayout.LayoutParams(-1, dp(8)).apply { topMargin = dp(12) }) panel.addView(progress, LinearLayout.LayoutParams(-1, dp(8)).apply { topMargin = dp(12) })
root.addView(panel, FrameLayout.LayoutParams(-1, -2, Gravity.BOTTOM).apply { root.addView(panel, FrameLayout.LayoutParams(-1, -2, Gravity.BOTTOM).apply {
leftMargin = dp(12); rightMargin = dp(12); bottomMargin = dp(12) leftMargin = dp(12); rightMargin = dp(12); bottomMargin = dp(12)
@@ -514,9 +661,16 @@ class MainActivity : ComponentActivity() {
private fun stopCamera() { private fun stopCamera() {
try { cameraProvider?.unbindAll() } catch (_: Exception) {} try { cameraProvider?.unbindAll() } catch (_: Exception) {}
cameraProvider = null cameraProvider = null
activeCamera = null
lastLockFocusAt = 0L
lastLockFocusX = -1f
lastLockFocusY = -1f
currentAnalyzer?.close() currentAnalyzer?.close()
currentAnalyzer = null currentAnalyzer = null
qrLockOverlay?.clear()
qrLockOverlay = null
scannerStatsText = null scannerStatsText = null
scannerLockText = null
scannerMode = ScannerMode.NONE scannerMode = ScannerMode.NONE
} }
@@ -32,18 +32,30 @@ data class Manifest(
) )
object QftProtocol { object QftProtocol {
const val PREFIX = "QFT1:" const val PREFIX = "QFT2:"
private const val VERSION = 1 private const val LEGACY_PREFIX = "QFT1:"
/** Active QFT2 path: Base45 keeps the QR in compact alphanumeric mode. */
fun parseText(text: String): QftFrame? { fun parseText(text: String): QftFrame? {
if (!text.startsWith(PREFIX)) return null return when {
val binary = try { text.startsWith(PREFIX) -> {
Base64Url.decode(text.substring(PREFIX.length)) ?: return null val binary = Base45.decode(text.substring(PREFIX.length)) ?: return null
} catch (_: IllegalArgumentException) { parseBinary(binary, expectedMagic = "QFT2", expectedVersion = 2)
return null }
text.startsWith(LEGACY_PREFIX) -> {
val binary = try {
Base64Url.decode(text.substring(LEGACY_PREFIX.length)) ?: return null
} catch (_: IllegalArgumentException) {
return null
}
parseBinary(binary, expectedMagic = "QFT1", expectedVersion = 1)
}
else -> null
} }
if (binary.size < 28) return null }
private fun parseBinary(binary: ByteArray, expectedMagic: String, expectedVersion: Int): QftFrame? {
if (binary.size < 28) return null
val bodySize = binary.size - 4 val bodySize = binary.size - 4
val expectedCrc = ByteBuffer.wrap(binary, bodySize, 4) val expectedCrc = ByteBuffer.wrap(binary, bodySize, 4)
.order(ByteOrder.BIG_ENDIAN) .order(ByteOrder.BIG_ENDIAN)
@@ -52,12 +64,10 @@ object QftProtocol {
if (crc != expectedCrc) return null if (crc != expectedCrc) return null
val bb = ByteBuffer.wrap(binary, 0, bodySize).order(ByteOrder.BIG_ENDIAN) val bb = ByteBuffer.wrap(binary, 0, bodySize).order(ByteOrder.BIG_ENDIAN)
val magic = ByteArray(4).also(bb::get) val magic = ByteArray(4).also(bb::get).toString(Charsets.US_ASCII)
if (!magic.contentEquals(byteArrayOf('Q'.code.toByte(), 'F'.code.toByte(), 'T'.code.toByte(), '1'.code.toByte()))) { if (magic != expectedMagic) return null
return null
}
val version = bb.get().toInt() and 0xff val version = bb.get().toInt() and 0xff
if (version != VERSION) return null if (version != expectedVersion) return null
val kind = try { FrameKind.fromWire(bb.get().toInt() and 0xff) } catch (_: Exception) { return null } val kind = try { FrameKind.fromWire(bb.get().toInt() and 0xff) } catch (_: Exception) { return null }
val sessionId = bb.long val sessionId = bb.long
val seq = bb.int.toLong() and 0xffff_ffffL val seq = bb.int.toLong() and 0xffff_ffffL
@@ -90,7 +100,6 @@ object QftProtocol {
.trim() .trim()
.ifBlank { "Windows-PC" } .ifBlank { "Windows-PC" }
} else { } else {
// Backward compatibility with v0.1/v0.1.2 manifests.
"Windows-PC" "Windows-PC"
} }
@@ -2,40 +2,76 @@ package com.qft.optical
import androidx.camera.core.ImageAnalysis import androidx.camera.core.ImageAnalysis
import androidx.camera.core.ImageProxy import androidx.camera.core.ImageProxy
import com.google.zxing.BarcodeFormat
import com.google.zxing.BinaryBitmap import com.google.zxing.BinaryBitmap
import com.google.zxing.DecodeHintType
import com.google.zxing.MultiFormatReader
import com.google.zxing.PlanarYUVLuminanceSource import com.google.zxing.PlanarYUVLuminanceSource
import com.google.zxing.Result
import com.google.zxing.common.GlobalHistogramBinarizer import com.google.zxing.common.GlobalHistogramBinarizer
import com.google.zxing.common.HybridBinarizer import com.google.zxing.common.HybridBinarizer
import java.util.concurrent.Callable import com.google.zxing.qrcode.QRCodeReader
import java.util.concurrent.Executors
/** One decoded QR result. QFT2 optical frames are consumed from text (Base45). */
data class DecodedQr(
val text: String,
val rawBytes: ByteArray?,
)
/**
* Single-channel high-frequency scanner.
*
* Acquisition: centered crop -> occasional full-frame search.
* Locked: only copy/decode the QR ROI, with progressive expansion on misses.
*
* The old four-reader/2x2 path is intentionally gone. One large QR gives the
* camera more pixels/module and lets the decoder spend CPU on one useful code.
*/
class QrAnalyzer( class QrAnalyzer(
private val profile: Profile, private val profile: Profile,
private val onTexts: (List<String>) -> Unit, private val onCode: (DecodedQr) -> Unit,
private val onStats: (cameraFramesPerSecond: Double, decodedPerSecond: Double) -> Unit = { _, _ -> }, private val onStats: (
cameraFramesPerSecond: Double,
decodedPerSecond: Double,
distinctPerSecond: Double,
averageDecodeMs: Double,
) -> Unit = { _, _, _, _ -> },
private val onLock: (ScannerLockState) -> Unit = {},
) : ImageAnalysis.Analyzer { ) : ImageAnalysis.Analyzer {
enum class Profile { PAIR_FAST, OPTICAL_MULTI } enum class Profile { PAIR_FAST, OPTICAL_LOCKED }
private val readers = Array(5) { newReader() } private val reader = QRCodeReader()
private val decodePool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors().coerceIn(2, 4)) private val grayBuffer = GrayFrameBuffer()
private var frameCounter = 0L private var frameCounter = 0L
private var decodedCounter = 0L private var decodedCounter = 0L
private var distinctCounter = 0L
private var lastFingerprint: Int? = null
private var decodeNanos = 0L
private var decodeAttempts = 0L
private var windowStarted = android.os.SystemClock.elapsedRealtime() private var windowStarted = android.os.SystemClock.elapsedRealtime()
private var lockRegion: LockRect? = null
private var lockMisses = 0
private var lastReportedLock: LockRect? = null
private var lastLockFlag = false
override fun analyze(image: ImageProxy) { override fun analyze(image: ImageProxy) {
try { try {
val gray = GrayFrame.from(image)
frameCounter++ frameCounter++
val results = when (profile) { val result = when (profile) {
Profile.PAIR_FAST -> decodePair(gray) Profile.PAIR_FAST -> decodePair(image)
Profile.OPTICAL_MULTI -> decodeOptical(gray) Profile.OPTICAL_LOCKED -> decodeOptical(image)
}.distinct() }
if (results.isNotEmpty()) { if (result != null) {
decodedCounter += results.size decodedCounter++
onTexts(results) val text = result.text.orEmpty()
val fingerprint = text.hashCode()
val isNew = lastFingerprint != fingerprint
if (isNew) {
distinctCounter++
lastFingerprint = fingerprint
// Dynamic optical frames often remain on screen for more than
// one camera exposure. Do not feed duplicates into the file
// assembler/UI; decoding stats still count the successful hit.
onCode(DecodedQr(text, result.rawBytes))
}
} }
reportStatsIfNeeded() reportStatsIfNeeded()
} finally { } finally {
@@ -43,120 +79,180 @@ class QrAnalyzer(
} }
} }
private fun decodePair(gray: GrayFrame): List<String> { private fun decodePair(image: ImageProxy): Result? {
// QFTPAIR2 is intentionally compact. Try a cheap centered GlobalHistogram // Pairing QR is static. Center-first keeps the common path cheap while
// pass first, then the full frame every time so off-axis scans do not wait // still allowing off-center framing every second frame.
// several frames. HybridBinarizer is reserved for every third miss. val center = LockRect.centeredSearch(image.width, image.height, 0.82f)
val marginX = (gray.width * 0.08).toInt() val centered = grayBuffer.capture(image, center)
val marginY = (gray.height * 0.08).toInt() decodeDense(centered, hybrid = false)?.let { return it }
decodeRegion(
gray, marginX, marginY, gray.width - marginX * 2, gray.height - marginY * 2, if (frameCounter % 2L == 0L) {
readers[0], hybridFallback = false, val full = grayBuffer.capture(image)
)?.let { return listOf(it) } decodeDense(full, hybrid = false)?.let { return it }
decodeRegion(gray, 0, 0, gray.width, gray.height, readers[0], hybridFallback = false) if (frameCounter % 6L == 0L) decodeDense(full, hybrid = true)?.let { return it }
?.let { return listOf(it) }
if (frameCounter % 3L == 0L) {
decodeRegion(gray, 0, 0, gray.width, gray.height, readers[0], hybridFallback = true)
?.let { return listOf(it) }
} }
return emptyList() return null
} }
private fun decodeOptical(gray: GrayFrame): List<String> { private fun decodeOptical(image: ImageProxy): Result? {
// v0.3 Windows can present a 2x2 grid. Decode quadrants concurrently. val current = lockRegion
// 8% overlap tolerates perspective/centering error around the middle. if (current != null) {
val overlapX = (gray.width * 0.08).toInt() // Fast hot path: only copy/decode the locked ROI. Most phones spend
val overlapY = (gray.height * 0.08).toInt() // far less time here than repeatedly scanning the entire frame.
val halfW = gray.width / 2 val crop = grayBuffer.capture(image, current)
val halfH = gray.height / 2 decodeDense(crop, hybrid = false)?.let { result ->
val regions = arrayOf( lockMisses = 0
intArrayOf(0, 0, (halfW + overlapX).coerceAtMost(gray.width), (halfH + overlapY).coerceAtMost(gray.height)), updateLockFromResult(result, crop)
intArrayOf((halfW - overlapX).coerceAtLeast(0), 0, gray.width - (halfW - overlapX).coerceAtLeast(0), (halfH + overlapY).coerceAtMost(gray.height)), return result
intArrayOf(0, (halfH - overlapY).coerceAtLeast(0), (halfW + overlapX).coerceAtMost(gray.width), gray.height - (halfH - overlapY).coerceAtLeast(0)), }
intArrayOf((halfW - overlapX).coerceAtLeast(0), (halfH - overlapY).coerceAtLeast(0), gray.width - (halfW - overlapX).coerceAtLeast(0), gray.height - (halfH - overlapY).coerceAtLeast(0)),
lockMisses++
// HybridBinarizer is slower but more robust against moire/exposure.
// Use it sparingly rather than doubling work on every camera frame.
if (lockMisses % 4 == 0) {
decodeDense(crop, hybrid = true)?.let { result ->
lockMisses = 0
updateLockFromResult(result, crop)
return result
}
}
// Follow small hand movement without immediately returning to a
// costly full-frame search. Only unlock after sustained misses.
if (lockMisses == 3 || lockMisses == 6) {
lockRegion = current.expand(
image.width,
image.height,
if (lockMisses == 3) 1.20f else 1.45f,
)
publishLock(image, locked = true)
}
if (lockMisses >= 10) {
lockRegion = null
lockMisses = 0
publishLock(image, locked = false)
}
return null
}
// Acquire: center-first, full frame every second camera frame. At the
// default 640x480 analysis size this is substantially cheaper than the
// previous 960x540 + four-region search.
val search = LockRect.centeredSearch(image.width, image.height, 0.84f)
val centered = grayBuffer.capture(image, search)
decodeDense(centered, hybrid = false)?.let { result ->
updateLockFromResult(result, centered)
return result
}
if (frameCounter % 2L == 0L) {
val full = grayBuffer.capture(image)
decodeDense(full, hybrid = false)?.let { result ->
updateLockFromResult(result, full)
return result
}
if (frameCounter % 6L == 0L) {
decodeDense(full, hybrid = true)?.let { result ->
updateLockFromResult(result, full)
return result
}
}
}
publishLock(image, locked = false)
return null
}
private fun decodeDense(gray: GrayFrame, hybrid: Boolean): Result? {
if (gray.width < 96 || gray.height < 96) return null
val source = PlanarYUVLuminanceSource(
gray.luma,
gray.width,
gray.height,
0,
0,
gray.width,
gray.height,
false,
) )
val tasks = regions.mapIndexed { index, r -> val started = System.nanoTime()
Callable { decodeAttempts++
decodeRegion(gray, r[0], r[1], r[2], r[3], readers[index], hybridFallback = false)
}
}
val found = try {
decodePool.invokeAll(tasks).mapNotNull { future ->
try { future.get() } catch (_: Exception) { null }
}
} catch (_: Exception) {
emptyList()
}
if (found.isNotEmpty()) return found
// Backward-compatible single-QR fallback. Limit the expensive hybrid
// pass to every third frame so low-end Android 7 devices stay responsive.
return if (frameCounter % 3L == 0L) {
decodeRegion(gray, 0, 0, gray.width, gray.height, readers[4], hybridFallback = true)
?.let(::listOf) ?: emptyList()
} else emptyList()
}
private fun decodeRegion(
gray: GrayFrame,
left: Int,
top: Int,
width: Int,
height: Int,
reader: MultiFormatReader,
hybridFallback: Boolean,
): String? {
if (width < 80 || height < 80) return null
val source = try {
PlanarYUVLuminanceSource(
gray.luma, gray.width, gray.height,
left.coerceAtLeast(0), top.coerceAtLeast(0),
width.coerceAtMost(gray.width - left.coerceAtLeast(0)),
height.coerceAtMost(gray.height - top.coerceAtLeast(0)),
false,
)
} catch (_: Exception) { return null }
try {
return reader.decodeWithState(BinaryBitmap(GlobalHistogramBinarizer(source)))?.text
} catch (_: Exception) {
if (!hybridFallback) return null
} finally {
reader.reset()
}
return try { return try {
reader.decodeWithState(BinaryBitmap(HybridBinarizer(source)))?.text val bitmap = if (hybrid) {
BinaryBitmap(HybridBinarizer(source))
} else {
BinaryBitmap(GlobalHistogramBinarizer(source))
}
reader.decode(bitmap)
} catch (_: Exception) { } catch (_: Exception) {
null null
} finally { } finally {
decodeNanos += System.nanoTime() - started
reader.reset() reader.reset()
} }
} }
private fun updateLockFromResult(result: Result, gray: GrayFrame) {
if (profile != Profile.OPTICAL_LOCKED) return
val points = result.resultPoints
?.map { (it.x + gray.originX) to (it.y + gray.originY) }
.orEmpty()
val measured = LockRect.fromPoints(points, gray.fullWidth, gray.fullHeight)
?: lockRegion
?: LockRect.centeredSearch(gray.fullWidth, gray.fullHeight, 0.62f)
// Smooth small finder-point jitter so the crop and on-screen overlay do
// not visibly vibrate while a dynamic QR is changing every frame.
val next = lockRegion?.smoothToward(measured, 0.30f) ?: measured
val changed = next.materiallyDiffers(lockRegion)
lockRegion = next
lockMisses = 0
if (changed || !lastLockFlag) {
publishLock(
frameWidth = gray.fullWidth,
frameHeight = gray.fullHeight,
rotationDegrees = gray.rotationDegrees,
locked = true,
)
}
}
private fun publishLock(image: ImageProxy, locked: Boolean) {
publishLock(image.width, image.height, image.imageInfo.rotationDegrees, locked)
}
private fun publishLock(frameWidth: Int, frameHeight: Int, rotationDegrees: Int, locked: Boolean) {
val region = lockRegion
val changed = locked != lastLockFlag || region?.materiallyDiffers(lastReportedLock) == true ||
(!locked && lastReportedLock != null)
if (!changed && frameCounter % 15L != 0L) return
lastLockFlag = locked
lastReportedLock = region
onLock(
ScannerLockState(
locked = locked,
region = region,
frameWidth = frameWidth,
frameHeight = frameHeight,
rotationDegrees = rotationDegrees,
misses = lockMisses,
searchAreaFraction = region?.areaFraction(frameWidth, frameHeight) ?: 1f,
)
)
}
private fun reportStatsIfNeeded() { private fun reportStatsIfNeeded() {
val now = android.os.SystemClock.elapsedRealtime() val now = android.os.SystemClock.elapsedRealtime()
val elapsed = now - windowStarted val elapsed = now - windowStarted
if (elapsed < 1000L) return if (elapsed < 1000L) return
val seconds = elapsed / 1000.0 val seconds = elapsed / 1000.0
onStats(frameCounter / seconds, decodedCounter / seconds) val averageMs = if (decodeAttempts == 0L) 0.0 else decodeNanos / 1_000_000.0 / decodeAttempts
onStats(frameCounter / seconds, decodedCounter / seconds, distinctCounter / seconds, averageMs)
frameCounter = 0 frameCounter = 0
decodedCounter = 0 decodedCounter = 0
distinctCounter = 0
decodeNanos = 0
decodeAttempts = 0
windowStarted = now windowStarted = now
} }
fun close() { fun close() = Unit
decodePool.shutdownNow()
}
companion object {
private fun newReader() = MultiFormatReader().apply {
setHints(
mapOf(
DecodeHintType.POSSIBLE_FORMATS to listOf(BarcodeFormat.QR_CODE),
DecodeHintType.TRY_HARDER to false,
DecodeHintType.CHARACTER_SET to "UTF-8",
)
)
}
}
} }
@@ -0,0 +1,154 @@
package com.qft.optical
import android.content.Context
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import android.graphics.Path
import android.graphics.PointF
import android.graphics.RectF
import android.view.View
import kotlin.math.max
/** Visualizes the ROI that the decoder is actually using. */
class QrLockOverlay(context: Context) : View(context) {
private val stroke = Paint(Paint.ANTI_ALIAS_FLAG).apply {
style = Paint.Style.STROKE
strokeWidth = resources.displayMetrics.density * 3f
}
private val shade = Paint(Paint.ANTI_ALIAS_FLAG).apply {
style = Paint.Style.FILL
color = 0x66000000
}
private val fill = Paint(Paint.ANTI_ALIAS_FLAG).apply {
style = Paint.Style.FILL
color = 0x1600E5A8
}
private val sweep = Paint(Paint.ANTI_ALIAS_FLAG).apply {
style = Paint.Style.STROKE
strokeWidth = resources.displayMetrics.density
color = 0x9920E3A2.toInt()
}
private var state: ScannerLockState? = null
fun update(next: ScannerLockState) {
state = next
invalidate()
}
fun clear() {
state = null
invalidate()
}
fun lockedCenterInView(): PointF? {
val s = state ?: return null
val region = s.region ?: return null
if (!s.locked || width <= 0 || height <= 0) return null
val rect = mapRegionToView(region, s)
return PointF(rect.centerX(), rect.centerY())
}
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
val s = state
if (s == null || width <= 0 || height <= 0) {
drawSearchGuide(canvas)
return
}
val region = s.region
if (!s.locked || region == null) {
drawSearchGuide(canvas)
return
}
val rect = mapRegionToView(region, s)
val radius = resources.displayMetrics.density * 14f
stroke.color = if (s.misses <= 2) 0xFF20E3A2.toInt() else 0xFFFFC857.toInt()
val pulse = ((android.os.SystemClock.uptimeMillis() / 180L) % 2L).toFloat()
stroke.strokeWidth = resources.displayMetrics.density * (if (pulse < 0.5f) 2.6f else 3.4f)
canvas.drawRoundRect(rect, radius, radius, fill)
val outside = Path().apply {
fillType = Path.FillType.EVEN_ODD
addRect(0f, 0f, width.toFloat(), height.toFloat(), Path.Direction.CW)
addRoundRect(rect, radius, radius, Path.Direction.CW)
}
canvas.drawPath(outside, shade)
canvas.drawRoundRect(rect, radius, radius, stroke)
drawCorners(canvas, rect, stroke)
// Lightweight dynamic sweep shows that the *locked ROI* is the active
// decoder area. This only animates the overlay; it never touches camera
// pixels or the ImageAnalysis thread.
val phase = (android.os.SystemClock.uptimeMillis() % 1200L) / 1200f
val scanY = rect.top + rect.height() * phase
sweep.color = if (s.misses <= 2) 0x9920E3A2.toInt() else 0x99FFC857.toInt()
canvas.drawLine(rect.left + rect.width() * 0.08f, scanY, rect.right - rect.width() * 0.08f, scanY, sweep)
postInvalidateDelayed(100L)
}
private fun drawSearchGuide(canvas: Canvas) {
val side = minOf(width, height) * 0.72f
val rect = RectF(
(width - side) / 2f,
(height - side) / 2f,
(width + side) / 2f,
(height + side) / 2f,
)
stroke.color = 0xCCFFFFFF.toInt()
stroke.strokeWidth = resources.displayMetrics.density * 2f
drawCorners(canvas, rect, stroke)
}
private fun drawCorners(canvas: Canvas, rect: RectF, paint: Paint) {
val len = minOf(rect.width(), rect.height()) * 0.12f
val p = Path()
p.moveTo(rect.left, rect.top + len); p.lineTo(rect.left, rect.top); p.lineTo(rect.left + len, rect.top)
p.moveTo(rect.right - len, rect.top); p.lineTo(rect.right, rect.top); p.lineTo(rect.right, rect.top + len)
p.moveTo(rect.left, rect.bottom - len); p.lineTo(rect.left, rect.bottom); p.lineTo(rect.left + len, rect.bottom)
p.moveTo(rect.right - len, rect.bottom); p.lineTo(rect.right, rect.bottom); p.lineTo(rect.right, rect.bottom - len)
canvas.drawPath(p, paint)
}
private fun mapRegionToView(region: LockRect, s: ScannerLockState): RectF {
val fw = s.frameWidth.toFloat().coerceAtLeast(1f)
val fh = s.frameHeight.toFloat().coerceAtLeast(1f)
val l = region.left / fw
val t = region.top / fh
val r = region.right / fw
val b = region.bottom / fh
val corners = arrayOf(
rotate(l, t, s.rotationDegrees), rotate(r, t, s.rotationDegrees),
rotate(l, b, s.rotationDegrees), rotate(r, b, s.rotationDegrees),
)
val minX = corners.minOf { it.first }
val maxX = corners.maxOf { it.first }
val minY = corners.minOf { it.second }
val maxY = corners.maxOf { it.second }
val rotatedW = if (s.rotationDegrees % 180 == 0) s.frameWidth.toFloat() else s.frameHeight.toFloat()
val rotatedH = if (s.rotationDegrees % 180 == 0) s.frameHeight.toFloat() else s.frameWidth.toFloat()
// PreviewView uses FILL_CENTER: scale to fill then crop equally.
val scale = max(width / rotatedW.coerceAtLeast(1f), height / rotatedH.coerceAtLeast(1f))
val renderedW = rotatedW * scale
val renderedH = rotatedH * scale
val offsetX = (width - renderedW) / 2f
val offsetY = (height - renderedH) / 2f
return RectF(
offsetX + minX * renderedW,
offsetY + minY * renderedH,
offsetX + maxX * renderedW,
offsetY + maxY * renderedH,
)
}
private fun rotate(x: Float, y: Float, degrees: Int): Pair<Float, Float> = when ((degrees % 360 + 360) % 360) {
90 -> (1f - y) to x
180 -> (1f - x) to (1f - y)
270 -> y to (1f - x)
else -> x to y
}
}
@@ -0,0 +1,11 @@
package com.qft.optical
data class ScannerLockState(
val locked: Boolean,
val region: LockRect?,
val frameWidth: Int,
val frameHeight: Int,
val rotationDegrees: Int,
val misses: Int,
val searchAreaFraction: Float,
)
@@ -30,9 +30,11 @@ class SessionAssembler(
@Synchronized @Synchronized
fun acceptText(text: String) { fun acceptText(text: String) {
val frame = QftProtocol.parseText(text) ?: return acceptFrame(QftProtocol.parseText(text) ?: return)
if (completedSession == frame.sessionId) return }
private fun acceptFrame(frame: QftFrame) {
if (completedSession == frame.sessionId) return
when (frame.kind) { when (frame.kind) {
FrameKind.MANIFEST -> acceptManifest(frame) FrameKind.MANIFEST -> acceptManifest(frame)
FrameKind.DATA -> acceptData(frame) FrameKind.DATA -> acceptData(frame)
@@ -0,0 +1,35 @@
package com.qft.optical
import org.junit.Assert.assertTrue
import org.junit.Test
class LockRectTest {
@Test fun finderPointsProduceBoundedSquareRoi() {
val lock = LockRect.fromPoints(
listOf(300f to 180f, 660f to 180f, 300f to 540f),
960,
720,
) ?: error("lock missing")
assertTrue(lock.width == lock.height)
assertTrue(lock.left >= 0 && lock.top >= 0)
assertTrue(lock.right <= 960 && lock.bottom <= 720)
assertTrue(lock.areaFraction(960, 720) < 0.36f)
}
@Test fun missesCanExpandRoiWithoutLeavingFrame() {
val base = LockRect(250, 100, 420, 420)
val expanded = base.expand(960, 540, 1.35f)
assertTrue(expanded.width >= base.width)
assertTrue(expanded.left >= 0 && expanded.top >= 0)
assertTrue(expanded.right <= 960 && expanded.bottom <= 540)
}
@Test fun smoothingReducesLockJitter() {
val a = LockRect(100, 100, 300, 300)
val b = LockRect(140, 130, 340, 340)
val smoothed = a.smoothToward(b, 0.25f)
assertTrue(smoothed.left in 101..139)
assertTrue(smoothed.top in 101..129)
assertTrue(smoothed.width in 301..339)
}
}
@@ -4,35 +4,30 @@ import org.junit.Assert.*
import org.junit.Test import org.junit.Test
import java.nio.ByteBuffer import java.nio.ByteBuffer
import java.nio.ByteOrder import java.nio.ByteOrder
import java.util.Base64
import java.util.zip.CRC32 import java.util.zip.CRC32
class ProtocolTest { class ProtocolTest {
@Test @Test
fun parsesDataFrameAndRejectsCorruption() { fun base45KnownVectors() {
assertArrayEquals("AB".toByteArray(), Base45.decode("BB8"))
assertArrayEquals("Hello!!".toByteArray(), Base45.decode("%69 VD92EX0"))
assertArrayEquals("base-45".toByteArray(), Base45.decode("UJCLQE7W581"))
}
@Test
fun parsesQft2DataFrameAndRejectsCorruption() {
val payload = byteArrayOf(1, 2, 3, 4, 5) val payload = byteArrayOf(1, 2, 3, 4, 5)
val text = encode(kind = 2, session = 7L, seq = 9, total = 11, payload = payload) val text = encodeQft2(kind = 2, session = 7L, seq = 9, total = 11, payload = payload)
val f = QftProtocol.parseText(text)!! val f = QftProtocol.parseText(text)!!
assertEquals(FrameKind.DATA, f.kind) assertEquals(FrameKind.DATA, f.kind)
assertEquals(7L, f.sessionId) assertEquals(7L, f.sessionId)
assertEquals(9L, f.seq) assertEquals(9L, f.seq)
assertArrayEquals(payload, f.payload) assertArrayEquals(payload, f.payload)
val corrupted = text.dropLast(1) + if (text.last() == 'A') "B" else "A" val corrupted = text.dropLast(1) + if (text.last() == '0') "1" else "0"
assertNull(QftProtocol.parseText(corrupted)) assertNull(QftProtocol.parseText(corrupted))
} }
@Test
fun parsesCrossLanguageKnownVector() {
val text = "QFT1:UUZUMQECAQIDBAUGBwgAAAADAAAACgAJaGVsbG8tcWZ0XhNTAg"
val f = QftProtocol.parseText(text)!!
assertEquals(FrameKind.DATA, f.kind)
assertEquals(0x0102030405060708L, f.sessionId)
assertEquals(3L, f.seq)
assertEquals(10L, f.totalChunks)
assertEquals("hello-qft", f.payload.toString(Charsets.UTF_8))
}
@Test @Test
fun parsesManifestSenderDevice() { fun parsesManifestSenderDevice() {
val name = "test.txt".toByteArray() val name = "test.txt".toByteArray()
@@ -41,26 +36,25 @@ class ProtocolTest {
val payload = ByteBuffer.allocate(8 + 2 + 32 + 2 + name.size + 2 + device.size) val payload = ByteBuffer.allocate(8 + 2 + 32 + 2 + name.size + 2 + device.size)
.order(ByteOrder.BIG_ENDIAN) .order(ByteOrder.BIG_ENDIAN)
.putLong(1234L) .putLong(1234L)
.putShort(700.toShort()) .putShort(450.toShort())
.put(sha) .put(sha)
.putShort(name.size.toShort()) .putShort(name.size.toShort())
.put(name) .put(name)
.putShort(device.size.toShort()) .putShort(device.size.toShort())
.put(device) .put(device)
.array() .array()
val text = encode(kind = 1, session = 77L, seq = 0, total = 2, payload = payload) val text = encodeQft2(kind = 1, session = 77L, seq = 0, total = 3, payload = payload)
val frame = QftProtocol.parseText(text)!! val manifest = QftProtocol.parseManifest(QftProtocol.parseText(text)!!)!!
val manifest = QftProtocol.parseManifest(frame)!!
assertEquals("DESKTOP-ZHY", manifest.senderDevice) assertEquals("DESKTOP-ZHY", manifest.senderDevice)
assertEquals("test.txt", manifest.fileName) assertEquals("test.txt", manifest.fileName)
assertEquals(1234L, manifest.fileSize) assertEquals(1234L, manifest.fileSize)
assertEquals(700, manifest.chunkSize) assertEquals(450, manifest.chunkSize)
} }
private fun encode(kind: Int, session: Long, seq: Int, total: Int, payload: ByteArray): String { private fun encodeQft2(kind: Int, session: Long, seq: Int, total: Int, payload: ByteArray): String {
val bb = ByteBuffer.allocate(24 + payload.size + 4).order(ByteOrder.BIG_ENDIAN) val bb = ByteBuffer.allocate(24 + payload.size + 4).order(ByteOrder.BIG_ENDIAN)
bb.put("QFT1".toByteArray()) bb.put("QFT2".toByteArray())
bb.put(1) bb.put(2)
bb.put(kind.toByte()) bb.put(kind.toByte())
bb.putLong(session) bb.putLong(session)
bb.putInt(seq) bb.putInt(seq)
@@ -70,6 +64,25 @@ class ProtocolTest {
val bodyLen = bb.position() val bodyLen = bb.position()
val crc = CRC32().apply { update(bb.array(), 0, bodyLen) }.value val crc = CRC32().apply { update(bb.array(), 0, bodyLen) }.value
bb.putInt(crc.toInt()) bb.putInt(crc.toInt())
return "QFT1:" + Base64.getUrlEncoder().withoutPadding().encodeToString(bb.array()) return "QFT2:" + base45Encode(bb.array())
}
private fun base45Encode(data: ByteArray): String {
val alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"
val out = StringBuilder((data.size * 3 + 1) / 2)
var i = 0
while (i + 1 < data.size) {
val value = (data[i].toInt() and 0xff) * 256 + (data[i + 1].toInt() and 0xff)
out.append(alphabet[value % 45])
out.append(alphabet[(value / 45) % 45])
out.append(alphabet[value / 2025])
i += 2
}
if (i < data.size) {
val value = data[i].toInt() and 0xff
out.append(alphabet[value % 45])
out.append(alphabet[value / 45])
}
return out.toString()
} }
} }
+67 -65
View File
@@ -1,86 +1,88 @@
# QFT protocol overview · v0.3.0-rc3 # QFT protocol notes — v0.4.0-rc2
## QFT1 — Windows → Android optical stream ## 1. Windows → Android optical: QFT2
Wire text: Active display text:
`QFT1:<base64url(binary frame)>` ```text
QFT2:<Base45(binary-frame)>
```
Binary frame fields: Base45 is used because its alphabet fits QR alphanumeric encoding, while Android can consume a normal ZXing `Result.text`. The receiver also keeps legacy `QFT1:<base64url(...)>` parsing for old senders.
- magic `QFT1` ### Binary frame
- protocol version
- frame kind: MANIFEST / DATA / END
- session id
- sequence index
- total chunks
- payload length
- payload
- CRC32
MANIFEST contains file name, file size, chunk size, total chunks, SHA-256 and Windows sender-device name. DATA frames are replayed cyclically; Android de-duplicates chunks and waits for missing chunks in later rounds. No Android→Windows feedback channel is used in optical mode. ```text
magic 4 "QFT2"
version 1 2
kind 1 1=MANIFEST / 2=DATA / 3=END
session 8 u64 BE
sequence 4 u32 BE
total 4 u32 BE
payloadLen 2 u16 BE
payload N
crc32 4 u32 BE over everything before crc32
```
v0.3 defaults: 900-byte DATA payload, 4 QR/page, target up to 60 pages/s. ### MANIFEST payload
## QFTPAIR2 — Android → Windows pairing ```text
fileSize 8 u64 BE
chunkSize 2 u16 BE
sha256 32
fileNameLen 2 u16 BE
fileName N UTF-8
senderLen 2 u16 BE
senderDevice N UTF-8
```
Text: ### Optical parameters in rc2
`QFTPAIR2:<base64url(compact JSON)>` - one QR per display frame;
- DATA payload: **450 B**;
- QR error correction: L;
- full 4-module quiet zone;
- Windows display target: 5~60 FPS, default 45;
- synthetic representative DATA frame: 722 text chars / QR-L v15;
- theoretical payload at 60 display FPS: 27,000 B/s ≈ 26.4 KiB/s before camera misses/replay.
Compact JSON keys: Sender continuously loops `MANIFEST → DATA 0..N-1 → END`. Android deduplicates by sequence number and reconstructs once all chunks are present. No reverse ACK/network channel exists for this direction.
- `v`: 2 ## 2. Android optical ROI state machine
- `s`: one-time session token
- `n`: Windows device name
- `p`: receiver TCP port
- `e`: local HTTP endpoint hints; Direct AP normally carries one short hint
- `w`: optional `[ssid, passphrase]` for QFT Direct
QFTPAIR1 remains parser-compatible for older QR payloads. ```text
ACQUIRE
center search
occasional full frame
↓ success
LOCKED
copy Y-plane ROI only
GlobalHistogram every frame
sparse Hybrid fallback
↓ finder points
smooth ROI position/size
↓ misses
expand ROI
↓ sustained misses
REACQUIRE
```
Android treats pairing QR as untrusted. HTTP endpoint hints must be literal private/local IPv4 addresses on the advertised port. Every `/qft/*` request must carry the one-time `X-QFT-Token` session value. The overlay is derived from the same ROI used by the decoder, so the green/yellow box is not decorative—it reflects the actual analysis area.
## Receiver discovery ## 3. Android → Windows pairing
UDP request to port 39392: `QFTPAIR2` remains the active pairing format from v0.3. It contains local-only session/network metadata. Android validates the pairing endpoint as a literal local/private IPv4 and binds subsequent discovery/upload to the selected local `Network`.
`QFTDISC2:<session>` Discovery order includes QR hint, UDP `QFTDISC2`, gateway/direct candidates and bounded current-subnet fallback.
Windows response: ## 4. Android → Windows upload
`QFTHERE2:<session>:<tcp_port>` Parallel v2 flow:
Android combines UDP result with QR hint, the actual connected Wi-Fi gateway, common Windows local addresses and a bounded current-subnet fallback scan. ```text
POST /qft/upload/init
POST /qft/upload/chunk (parallel, offset based)
POST /qft/upload/finish
```
## Parallel v2 upload Windows preallocates a `.qftpart`, writes chunks at explicit offsets, verifies SHA-256, then renames to the final file. Per-file worker count is capped at 8; chunk size is selected from 4/8/16 MiB by file size.
### Ping
`GET /qft/ping`
Headers include `X-QFT-Token` and encoded Android device name.
### Init
`POST /qft/upload/init`
Headers include file name, file size and desired chunk size. Android requests 4/8/16 MiB depending on file size; Windows clamps accepted chunks to 1~16 MiB.
Response includes `upload_id`, accepted `chunk_size`, and `total_chunks`.
### Chunk
`POST /qft/upload/chunk/<upload_id>/<index>`
Body is exactly that file range. Up to eight Android workers send distinct chunks concurrently. Windows writes each accepted chunk to the preallocated `.qftpart` file at its deterministic offset.
### Finish
`POST /qft/upload/finish/<upload_id>`
Windows rejects finish while chunks are missing. Once complete it computes SHA-256, renames the temporary file to its final unique name, and returns success.
### Compatibility
`POST /qft/upload` remains the single-stream fallback for old clients or content providers that cannot sustain seekable parallel reads.
+12 -54
View File
@@ -1,58 +1,16 @@
# Roadmap # QFT Roadmap
## V0.1 — 单 QR 无网络链路(当前) ## v0.4 physical validation
- Windows 选择文件 1. Use **450 B / single QR** as the baseline and measure real-phone distinct new-frame/s at Windows 30 / 45 / 60 FPS.
- 单 QR 动画 2. Record lock acquisition time, locked ROI area, camera FPS, successful decode/s, distinct new-frame/s and reacquire time per device.
- Android CameraX 连续识别 3. Only after real-device data exists, test nearby DATA payloads (e.g. 390 / 450 / 510 B) and keep the value with the highest *effective* file throughput rather than the highest theoretical bytes/frame.
- CRC32 4. Add optional Windows FPS presets chosen from observed Android effective new-frame/s; the optical transport itself remains strictly one-way.
- SHA-256 5. Tune focus/exposure behavior across LCD/OLED and 60/120 Hz panels.
- 重复帧去重
- 多轮补洞
- 保存 Downloads/QFT
目标不是速度,而是证明:**飞行模式下可稳定完整恢复真实文件**。 ## Later
## V0.2 — 扫码稳定性 - Fountain/RaptorQ to reduce whole-playlist replay cost without a reverse ACK channel.
- Native SIMD/custom visual decoder if ZXing remains the dominant bottleneck.
- 自动曝光/对焦锁定 - Optional custom QFT Visual Code after the single-QR baseline is measured.
- 只分析中央 ROI - iOS/macOS/Linux clients.
- 720p/1080p 自适应
- 帧序号抖动统计
- 自动 FPS 调节
- QR 版本/纠错级别动态选择
- Android 前台常亮、屏幕方向锁定
## V0.3 — 多 QR
- Windows 2x2 -> 3x3 网格
- Android 一帧多码检测
- 每个位置独立 lane
- lane interleave,避免同一丢帧损失连续数据
## V0.4 — Fountain / RaptorQ
- source block / symbol
- 无需等待指定 seq
- 达到恢复阈值即可完成
- 发送端持续产生 repair symbols
- 删除“整文件循环重播”的尾部等待
## V0.5 — QFT Visual Code
- 固定四角定位
- 自定义二值网格
- BCH/LDPC 内层纠错
- SIMD 二值化与采样
- 60/120 FPS
- 标定显示器刷新率与相机 rolling shutter
## V0.6 — Android -> Windows
这个方向因 PC 可能无摄像头,使用 App P2P:
- 同 LAN
- 临时热点
- Wi-Fi Direct(可用平台)
- QUIC
- 不经过外网/云端
+22 -22
View File
@@ -1,27 +1,27 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
from pathlib import Path from pathlib import Path
import re import re
ROOT = Path(__file__).resolve().parents[1] ROOT=Path(__file__).resolve().parents[1]
gradle = (ROOT/'android/app/build.gradle.kts').read_text() gradle=(ROOT/'android/app/build.gradle.kts').read_text(); manifest=(ROOT/'android/app/src/main/AndroidManifest.xml').read_text()
manifest = (ROOT/'android/app/src/main/AndroidManifest.xml').read_text() wifi=(ROOT/'android/app/src/main/java/com/qft/optical/WifiConnector.kt').read_text(); upload=(ROOT/'android/app/src/main/java/com/qft/optical/UploadClient.kt').read_text()
wifi = (ROOT/'android/app/src/main/java/com/qft/optical/WifiConnector.kt').read_text() main=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text(); analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text()
upload = (ROOT/'android/app/src/main/java/com/qft/optical/UploadClient.kt').read_text() gray=(ROOT/'android/app/src/main/java/com/qft/optical/GrayFrame.kt').read_text(); protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text(); base45=(ROOT/'android/app/src/main/java/com/qft/optical/Base45.kt').read_text(); overlay=(ROOT/'android/app/src/main/java/com/qft/optical/QrLockOverlay.kt').read_text(); security=(ROOT/'android/app/src/main/res/xml/network_security_config.xml').read_text()
main = (ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text() assert re.search(r'minSdk\s*=\s*24',gradle)
gray = (ROOT/'android/app/src/main/java/com/qft/optical/GrayFrame.kt').read_text()
security = (ROOT/'android/app/src/main/res/xml/network_security_config.xml').read_text()
assert re.search(r'minSdk\s*=\s*24', gradle)
assert 'WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28"' in manifest assert 'WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28"' in manifest
assert 'ACCESS_FINE_LOCATION" android:maxSdkVersion="32"' in manifest assert 'ACCESS_FINE_LOCATION" android:maxSdkVersion="32"' in manifest and 'NEARBY_WIFI_DEVICES' in manifest
assert 'NEARBY_WIFI_DEVICES' in manifest assert 'networkSecurityConfig="@xml/network_security_config"' in manifest and 'cleartextTrafficPermitted="true"' in security
assert 'networkSecurityConfig="@xml/network_security_config"' in manifest assert 'Build.VERSION.SDK_INT >= 29' in wifi and 'connectLegacy' in wifi and 'subnetEndpoints' in wifi and 'directedBroadcast' in wifi
assert 'cleartextTrafficPermitted="true"' in security assert 'MAX_WORKERS = 8' in upload and 'QFTDISC2:' in upload
assert 'Build.VERSION.SDK_INT >= 29' in wifi and 'connectLegacy' in wifi assert 'val targetSize = Size(640, 480)' in main and 'Size(960, 540)' not in main
assert 'subnetEndpoints' in wifi and 'directedBroadcast' in wifi assert 'Camera2Interop.Extender' in main and 'CONTROL_AE_TARGET_FPS_RANGE' in main and 'STRATEGY_KEEP_ONLY_LATEST' in main
assert 'MAX_WORKERS = 8' in upload and 'QFTDISC2:' in upload and 'workers = 24' in upload and 'desiredChunkSize' in upload and 'CHUNK_LARGE' in upload assert '设备拒绝显式高帧率请求' in main and 'fallbackAnalysis' in main
assert 'Size(640, 480)' in main and 'Size(1280, 720)' in main assert 'OPTICAL_LOCKED' in analyzer and 'OPTICAL_MULTI' not in analyzer and 'QRCodeReader' in analyzer and 'MultiFormatReader' not in analyzer
assert 'STRATEGY_KEEP_ONLY_LATEST' in main assert 'LockRect.fromPoints' in analyzer and 'grayBuffer.capture(image, current)' in analyzer
assert 'rotate90' not in gray and 'image.imageInfo.rotationDegrees' not in gray assert 'GrayFrameBuffer' in gray and 'scratch = ByteArray(0)' in gray
all_kotlin = '\n'.join(path.read_text() for path in (ROOT/'android/app/src/main/java/com/qft/optical').glob('*.kt')) assert 'Base45.decode' in protocol and 'QFT2' in protocol and 'looksLikeBinaryFrame' not in protocol
assert 'lockedCenterInView' in overlay and 'postInvalidateDelayed' in overlay and 'maybeRefocusLockedQr' in main
assert 'assembler.acceptText(code.text)' in main and 'acceptBinary' not in main
assert 'BB8' in base45 or 'ALPHABET' in base45
all_kotlin='\n'.join(path.read_text() for path in (ROOT/'android/app/src/main/java/com/qft/optical').glob('*.kt'))
assert 'java.util.Base64' not in all_kotlin assert 'java.util.Base64' not in all_kotlin
print('PASS Android compatibility/static guards: minSdk24, API29 split, legacy storage/location, Android13 nearby-WiFi, cleartext local config, subnet fallback, fast scanner paths') print('PASS Android static guards: API24+, 640x480 single-QR ROI, reusable luma buffer, QFT2/Base45 text parse, dynamic lock/refocus, Camera2 FPS request, legacy/new Wi-Fi compatibility')
+52
View File
@@ -0,0 +1,52 @@
#!/usr/bin/env python3
"""Host-side Kotlin smoke tests. Uses kotlinc if present; does not require Android SDK."""
from pathlib import Path
import shutil, subprocess, tempfile, textwrap, os
ROOT=Path(__file__).resolve().parents[1]
K=ROOT/'android/app/src/main/java/com/qft/optical'
kotlinc=shutil.which('kotlinc')
if not kotlinc:
print('SKIP Kotlin host smoke: kotlinc not installed (Android Gradle tests still cover these files on a dev host)')
raise SystemExit(0)
def run(args):
env=os.environ.copy(); env.setdefault('TERM','xterm')
p=subprocess.run(args, text=True, capture_output=True, env=env)
if p.returncode:
print(p.stdout); print(p.stderr); raise SystemExit(p.returncode)
with tempfile.TemporaryDirectory() as td:
td=Path(td)
smoke=td/'Smoke.kt'
smoke.write_text(textwrap.dedent(r'''
package com.qft.optical
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.util.zip.CRC32
fun b45e(data: ByteArray): String { val a="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"; val o=StringBuilder(); var i=0; while(i+1<data.size){val v=(data[i].toInt() and 255)*256+(data[i+1].toInt() and 255);o.append(a[v%45]).append(a[(v/45)%45]).append(a[v/2025]);i+=2};if(i<data.size){val v=data[i].toInt() and 255;o.append(a[v%45]).append(a[v/45])};return o.toString() }
fun fr(p:ByteArray):String { val b=ByteBuffer.allocate(24+p.size+4).order(ByteOrder.BIG_ENDIAN);b.put("QFT2".toByteArray()).put(2).put(2).putLong(7L).putInt(9).putInt(11).putShort(p.size.toShort()).put(p);val n=b.position();val c=CRC32().apply{update(b.array(),0,n)}.value;b.putInt(c.toInt());return "QFT2:"+b45e(b.array()) }
fun main(){check(Base45.decode("BB8")!!.contentEquals("AB".toByteArray()));check(Base45.decode("%69 VD92EX0")!!.contentEquals("Hello!!".toByteArray()));val p="hello-qft2".toByteArray();val f=QftProtocol.parseText(fr(p))!!;check(f.kind==FrameKind.DATA&&f.sessionId==7L&&f.seq==9L&&f.payload.contentEquals(p));val c=LockRect(100,100,300,300).smoothToward(LockRect(140,130,340,340),.25f);check(c.left in 101..139);println("PASS Kotlin QFT2/Base45 protocol + ROI lock smoothing")}
'''))
jar=td/'smoke.jar'
run([kotlinc, str(K/'Base45.kt'), str(K/'Base64Url.kt'), str(K/'Protocol.kt'), str(K/'LockRect.kt'), str(smoke), '-include-runtime', '-d', str(jar)])
p=subprocess.run(['java','-jar',str(jar)],text=True,capture_output=True,env={**os.environ,'TERM':'xterm'},check=True)
print(p.stdout.strip())
# CameraX/ZXing-shaped compile stubs: catches Kotlin signature/syntax drift in the analyzer without Android SDK.
for d in ['android/os','androidx/camera/core','com/google/zxing/common','com/google/zxing/qrcode','com/google/zxing']:
(td/d).mkdir(parents=True,exist_ok=True)
(td/'android/os/SystemClock.kt').write_text('package android.os\nobject SystemClock { fun elapsedRealtime(): Long = 0L }\n')
(td/'androidx/camera/core/Core.kt').write_text(textwrap.dedent('''
package androidx.camera.core
import java.nio.ByteBuffer
interface ImageAnalysis { interface Analyzer { fun analyze(image: ImageProxy) } }
interface ImageProxy { val width:Int; val height:Int; val planes:Array<PlaneProxy>; val imageInfo:ImageInfo; fun close(); interface PlaneProxy { val buffer:ByteBuffer; val rowStride:Int; val pixelStride:Int }; interface ImageInfo { val rotationDegrees:Int } }
'''))
(td/'com/google/zxing/Zxing.kt').write_text('package com.google.zxing\nopen class LuminanceSource(val width:Int,val height:Int)\nclass PlanarYUVLuminanceSource(data:ByteArray,dataWidth:Int,dataHeight:Int,left:Int,top:Int,width:Int,height:Int,reverseHorizontal:Boolean):LuminanceSource(width,height)\nclass BinaryBitmap(val binarizer:Any)\ndata class ResultPoint(val x:Float,val y:Float)\nclass Result(val text:String?="",val rawBytes:ByteArray?=null,val resultPoints:Array<ResultPoint>?=null)\n')
(td/'com/google/zxing/common/Common.kt').write_text('package com.google.zxing.common\nimport com.google.zxing.LuminanceSource\nclass GlobalHistogramBinarizer(source:LuminanceSource)\nclass HybridBinarizer(source:LuminanceSource)\n')
(td/'com/google/zxing/qrcode/QRCodeReader.kt').write_text('package com.google.zxing.qrcode\nimport com.google.zxing.BinaryBitmap\nimport com.google.zxing.Result\nclass QRCodeReader { fun decode(bitmap:BinaryBitmap):Result=Result(); fun reset(){} }\n')
out=td/'analyzer.jar'
sources=[td/'android/os/SystemClock.kt',td/'androidx/camera/core/Core.kt',td/'com/google/zxing/Zxing.kt',td/'com/google/zxing/common/Common.kt',td/'com/google/zxing/qrcode/QRCodeReader.kt',K/'LockRect.kt',K/'ScannerLockState.kt',K/'GrayFrame.kt',K/'QrAnalyzer.kt']
run([kotlinc,*map(str,sources),'-d',str(out)])
print('PASS Kotlin QrAnalyzer compile smoke with CameraX/ZXing-shaped stubs')
+6 -13
View File
@@ -2,16 +2,9 @@
MAX_CACHE_MIB = 768 MAX_CACHE_MIB = 768
MAX_PAGES = 192 MAX_PAGES = 192
HARD_MIB = 1100 HARD_MIB = 1100
SIDE = 1024
def calc(side): bpp = SIDE * SIDE * 4
bpp = side * side * 4 pages = max(4, min(MAX_PAGES, MAX_CACHE_MIB * 1024 * 1024 // bpp))
pages = max(4, min(MAX_PAGES, MAX_CACHE_MIB * 1024 * 1024 // bpp)) managed = pages * bpp / (1024 * 1024)
managed = pages * bpp / (1024 * 1024) assert managed + 96 < HARD_MIB
return pages, managed print(f"PASS memory budget: single-QR cache={pages} frames/{managed:.1f} MiB + 96 MiB transient allowance < {HARD_MIB} MiB")
p4, m4 = calc(960)
p1, m1 = calc(760)
# Include a conservative 64 MiB transient batch/decoder allowance in this design-level bound.
assert m4 + 64 < HARD_MIB
assert m1 + 64 < HARD_MIB
print(f"PASS memory budget: 4QR cache={p4} pages/{m4:.1f} MiB; 1QR cache={p1} pages/{m1:.1f} MiB; hard design ceiling={HARD_MIB} MiB")
+43 -47
View File
@@ -1,55 +1,51 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""Synthetic visual-path smoke test for the 4-QR optical page and QFTPAIR2. """Synthetic QFT2/Base45 single-QR acquisition/ROI smoke test. Not a physical camera test."""
Requires: qrcode, numpy, opencv-python, pyzbar/libzbar. import binascii, os, struct, time
This is intentionally not a substitute for a real display/camera test.
"""
import base64, json, os, time
import cv2 import cv2
import numpy as np import numpy as np
import qrcode import qrcode
from pyzbar.pyzbar import decode as zdecode, ZBarSymbol from pyzbar.pyzbar import decode as zdecode, ZBarSymbol
from qrcode.constants import ERROR_CORRECT_L, ERROR_CORRECT_M from qrcode.constants import ERROR_CORRECT_L
B45="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"
def b45(data):
out=[]; i=0
while i+1 < len(data):
v=data[i]*256+data[i+1]; out += [B45[v%45],B45[(v//45)%45],B45[v//2025]]; i+=2
if i<len(data):
v=data[i]; out += [B45[v%45],B45[v//45]]
return ''.join(out)
def make_qr(text: str, ec, target: int): payload=os.urandom(450)
qr = qrcode.QRCode(version=None, error_correction=ec, box_size=1, border=4) body=b"QFT2"+bytes([2,2])+struct.pack(">QIIH",0x1020304050607080,7,1000,len(payload))+payload
qr.add_data(text); qr.make(fit=True) raw=body+struct.pack(">I",binascii.crc32(body)&0xffffffff)
mat = np.asarray(qr.get_matrix(), dtype=np.uint8) text="QFT2:"+b45(raw)
scale = max(1, target // mat.shape[0]) qr=qrcode.QRCode(version=None,error_correction=ERROR_CORRECT_L,box_size=1,border=4)
return ((1 - np.kron(mat, np.ones((scale, scale), np.uint8))) * 255).astype(np.uint8), qr.version qr.add_data(text); qr.make(fit=True)
assert qr.version <= 15, qr.version
mat=np.asarray(qr.get_matrix(),dtype=np.uint8)
# Make the large single code fill ~70% of the 480px analysis height.
scale=max(1,340//mat.shape[0])
symbol=((1-np.kron(mat,np.ones((scale,scale),np.uint8)))*255).astype(np.uint8)
canvas=np.full((480,640),255,np.uint8)
side=symbol.shape[0]; x=max(8,(640-side)//2); y=max(8,(480-side)//2)
canvas[y:y+side,x:x+side]=symbol
rot=cv2.getRotationMatrix2D((320,240),3.0,1.0)
frame=cv2.warpAffine(canvas,rot,(640,480),borderValue=255)
frame=cv2.GaussianBlur(frame,(3,3),0.35)
expected=text.encode()
found=zdecode(frame,symbols=[ZBarSymbol.QRCODE]); assert any(r.data==expected for r in found)
r=next(r for r in found if r.data==expected)
pad=int(max(r.rect.width,r.rect.height)*0.08)
l=max(0,r.rect.left-pad); t=max(0,r.rect.top-pad); rr=min(frame.shape[1],r.rect.left+r.rect.width+pad); bb=min(frame.shape[0],r.rect.top+r.rect.height+pad)
roi=frame[t:bb,l:rr]
assert any(z.data==expected for z in zdecode(roi,symbols=[ZBarSymbol.QRCODE]))
area=roi.size/frame.size; assert area < 0.80
# Four data QR symbols at the same density used by v0.3 (about 1243 chars/frame). def avg_ms(img,loops=40):
texts = ["QFT1:" + base64.urlsafe_b64encode(os.urandom(928)).decode().rstrip("=") for _ in range(4)] started=time.perf_counter()
canvas = np.full((960, 960), 255, np.uint8) for _ in range(loops): zdecode(img,symbols=[ZBarSymbol.QRCODE])
gutter = 15 return (time.perf_counter()-started)*1000/loops
cell = (960 - gutter * 3) // 2 full_ms=avg_ms(frame); roi_ms=avg_ms(roi)
for idx, text in enumerate(texts): assert roi_ms < full_ms*1.15
img, version = make_qr(text, ERROR_CORRECT_L, cell) print(f"PASS synthetic QFT2 lock: QR-L v{qr.version}, {len(text)} chars; full={full_ms:.1f}ms, lockedROI={roi_ms:.1f}ms, ROI area={area*100:.1f}%")
row, col = divmod(idx, 2)
x = gutter + col * (cell + gutter) + (cell - img.shape[1]) // 2
y = gutter + row * (cell + gutter) + (cell - img.shape[0]) // 2
canvas[y:y+img.shape[0], x:x+img.shape[1]] = img
started = time.perf_counter()
found = {r.data.decode() for r in zdecode(canvas, symbols=[ZBarSymbol.QRCODE])}
elapsed = time.perf_counter() - started
assert found == set(texts), (len(found), len(texts))
# Pairing QR: downscale + rotate + slight blur to exercise acquisition margin.
v2 = {
"v":2,"s":"qft_test_session_128bit_XY","n":"DESKTOP-QFT","p":39393,
"e":["http://192.168.137.1:39393"],
"w":["QFT-DESKTOP-abc123","3xamplePassw0rd"],
}
raw = json.dumps(v2, separators=(",", ":"), ensure_ascii=False).encode()
pair_text = "QFTPAIR2:" + base64.urlsafe_b64encode(raw).decode().rstrip("=")
pair, pair_ver = make_qr(pair_text, ERROR_CORRECT_M, 520)
pair = cv2.resize(pair, (260, 260), interpolation=cv2.INTER_NEAREST)
rot = cv2.getRotationMatrix2D((130, 130), 7.0, 1.0)
pair = cv2.warpAffine(pair, rot, (300, 300), borderValue=255)
pair = cv2.GaussianBlur(pair, (3, 3), 0.5)
started2 = time.perf_counter()
pair_found = [r.data.decode() for r in zdecode(pair, symbols=[ZBarSymbol.QRCODE])]
elapsed2 = time.perf_counter() - started2
assert pair_text in pair_found
print(f"PASS synthetic QR decode: 4/4 optical QR v{version} decoded from 960px page in {elapsed*1000:.1f} ms; "
f"QFTPAIR2 QR-M v{pair_ver} decoded after 7deg rotate+blur in {elapsed2*1000:.1f} ms")
+89 -71
View File
@@ -3,96 +3,114 @@ import base64, binascii, hashlib, math, os, random, struct
import qrcode import qrcode
from qrcode.constants import ERROR_CORRECT_L from qrcode.constants import ERROR_CORRECT_L
PREFIX = "QFT1:" PREFIX = "QFT2:"
CHUNK = 900 LEGACY_PREFIX = "QFT1:"
LANES = 4 CHUNK = 450
DISPLAY_FPS = 60 DISPLAY_FPS = 60
B45 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"
def enc(kind, sid, seq, total, payload=b""): def b45encode(data: bytes) -> str:
out=[]
i=0
while i+1 < len(data):
v=data[i]*256+data[i+1]
out += [B45[v%45], B45[(v//45)%45], B45[v//2025]]
i += 2
if i < len(data):
v=data[i]
out += [B45[v%45], B45[v//45]]
return ''.join(out)
def b45decode(text: str) -> bytes:
rev={c:i for i,c in enumerate(B45)}
out=bytearray(); i=0
while i < len(text):
rem=len(text)-i
if rem == 1: raise ValueError('bad Base45 length')
if rem >= 3:
v=rev[text[i]] + 45*rev[text[i+1]] + 2025*rev[text[i+2]]
if v > 0xffff: raise ValueError('overflow')
out += bytes((v//256, v%256)); i += 3
else:
v=rev[text[i]] + 45*rev[text[i+1]]
if v > 0xff: raise ValueError('overflow')
out.append(v); i += 2
return bytes(out)
def enc_binary(kind, sid, seq, total, payload=b""):
body = b"QFT2" + bytes([2, kind]) + struct.pack(">QIIH", sid, seq, total, len(payload)) + payload
crc = binascii.crc32(body) & 0xFFFFFFFF
return body + struct.pack(">I", crc)
def enc_text(kind, sid, seq, total, payload=b""):
return PREFIX + b45encode(enc_binary(kind, sid, seq, total, payload))
def legacy_text(kind, sid, seq, total, payload=b""):
body = b"QFT1" + bytes([1, kind]) + struct.pack(">QIIH", sid, seq, total, len(payload)) + payload body = b"QFT1" + bytes([1, kind]) + struct.pack(">QIIH", sid, seq, total, len(payload)) + payload
crc = binascii.crc32(body) & 0xFFFFFFFF crc = binascii.crc32(body) & 0xFFFFFFFF
return PREFIX + base64.urlsafe_b64encode(body + struct.pack(">I", crc)).decode().rstrip("=") raw=body+struct.pack(">I",crc)
return LEGACY_PREFIX + base64.urlsafe_b64encode(raw).decode().rstrip('=')
def dec(text): def dec_text(text):
assert text.startswith(PREFIX) assert text.startswith(PREFIX)
b64 = text[len(PREFIX):] raw=b45decode(text[len(PREFIX):])
raw = base64.urlsafe_b64decode(b64 + "=" * (-len(b64) % 4))
body, crc_raw = raw[:-4], raw[-4:] body, crc_raw = raw[:-4], raw[-4:]
assert (binascii.crc32(body) & 0xFFFFFFFF) == struct.unpack(">I", crc_raw)[0] assert (binascii.crc32(body) & 0xFFFFFFFF) == struct.unpack(">I", crc_raw)[0]
assert body[:4] == b"QFT1" and body[4] == 1 assert body[:4] == b"QFT2" and body[4] == 2
kind = body[5] kind=body[5]
sid, seq, total, plen = struct.unpack(">QIIH", body[6:24]) sid,seq,total,plen=struct.unpack(">QIIH", body[6:24])
payload = body[24:] payload=body[24:]
assert len(payload) == plen assert len(payload)==plen
return kind, sid, seq, total, payload return kind,sid,seq,total,payload
def test_qr_density(sample): def qr_info(sample: str):
qr = qrcode.QRCode(version=None, error_correction=ERROR_CORRECT_L, box_size=1, border=4) qr=qrcode.QRCode(version=None,error_correction=ERROR_CORRECT_L,box_size=1,border=4)
qr.add_data(sample) qr.add_data(sample); qr.make(fit=True)
qr.make(fit=True) modules_with_quiet=qr.modules_count+8
modules_with_quiet = qr.modules_count + 8 return qr.version, 1024//modules_with_quiet, modules_with_quiet
canvas = 960
gutter = max(12, min(24, canvas // 64))
cell = (canvas - gutter * 3) // 2
module_px = cell // modules_with_quiet
assert module_px >= 3, (qr.version, qr.modules_count, cell, module_px)
return qr.version, module_px, len(sample)
def main(): def main():
assert b45encode(b"AB") == "BB8" and b45decode("BB8") == b"AB"
assert b45encode(b"Hello!!") == "%69 VD92EX0" and b45decode("%69 VD92EX0") == b"Hello!!"
assert b45encode(b"base-45") == "UJCLQE7W581" and b45decode("UJCLQE7W581") == b"base-45"
random.seed(20260810) random.seed(20260810)
data = os.urandom(2_500_123) data=os.urandom(1_200_123); digest=hashlib.sha256(data).digest()
digest = hashlib.sha256(data).digest() total=math.ceil(len(data)/CHUNK); sid=0x1234567890ABCDEF
total = math.ceil(len(data) / CHUNK) name=b"sample.bin"; device=b"DESKTOP-QFT"
sid = 0x1234567890ABCDEF manifest=struct.pack(">QH",len(data),CHUNK)+digest+struct.pack(">H",len(name))+name+struct.pack(">H",len(device))+device
name = b"sample.bin" playlist=[enc_text(1,sid,0,total,manifest)]
device = b"DESKTOP-QFT" playlist += [enc_text(2,sid,i,total,data[i*CHUNK:(i+1)*CHUNK]) for i in range(total)]
manifest = ( playlist += [enc_text(3,sid,0,total)]
struct.pack(">QH", len(data), CHUNK)
+ digest
+ struct.pack(">H", len(name)) + name
+ struct.pack(">H", len(device)) + device
)
playlist = [enc(1, sid, 0, total, manifest)]
playlist += [enc(2, sid, i, total, data[i*CHUNK:(i+1)*CHUNK]) for i in range(total)]
playlist += [enc(3, sid, 0, total)]
pages = [playlist[i:i+LANES] for i in range(0, len(playlist), LANES)]
version, module_px, chars = test_qr_density(playlist[min(2, len(playlist)-1)]) sample=playlist[min(2,len(playlist)-1)]
version,module_px,modules=qr_info(sample)
legacy=legacy_text(2,sid,0,total,os.urandom(480))
legacy_version,legacy_px,_=qr_info(legacy)
assert version <= 15,(version,len(sample))
assert module_px >= 10,(version,modules,module_px)
assert version < legacy_version,(version,legacy_version)
got = [None] * total got=[None]*total; rounds=0
rounds = 0
manifests = 0
# Model both whole-camera-frame losses and per-lane decode failures.
while any(x is None for x in got): while any(x is None for x in got):
rounds += 1 rounds += 1
for page in pages: for text in playlist:
if random.random() < 0.24: # display page/camera frame missed if random.random() < 0.22: continue
continue kind,rsid,seq,rtotal,payload=dec_text(text)
for text in page: assert rsid==sid and rtotal==total
if random.random() < 0.14: # one quadrant not decoded if kind==2 and got[seq] is None: got[seq]=payload
continue
kind, rsid, seq, rtotal, payload = dec(text)
assert rsid == sid and rtotal == total
if kind == 1:
manifests += 1
elif kind == 2 and got[seq] is None:
got[seq] = payload
assert rounds < 60 assert rounds < 60
rebuilt=b''.join(got)[:len(data)]
assert rebuilt==data and hashlib.sha256(rebuilt).digest()==digest
rate=CHUNK*DISPLAY_FPS
print(f"PASS QFT2/Base45 single-QR: {len(data)} bytes, {total} chunks, 22% frame loss, recovered in {rounds} rounds; QR-L v{version} vs legacy Base64 v{legacy_version}, {module_px}px/module@1024, text={len(sample)} chars, theoretical payload={rate/1024:.1f} KiB/s")
rebuilt = b"".join(got)[:len(data)] if __name__=='__main__': main()
assert rebuilt == data
assert hashlib.sha256(rebuilt).digest() == digest
raw_rate = CHUNK * LANES * DISPLAY_FPS
print(
f"PASS optical: {len(data)} bytes, {total} chunks, {LANES} QR/page @ {DISPLAY_FPS} FPS, "
f"24% page loss + 14% lane loss, recovered in {rounds} rounds; "
f"QR v{version}, {module_px}px/module, frame chars={chars}, theoretical payload={raw_rate/1024:.1f} KiB/s"
)
if __name__ == "__main__":
main()
+4
View File
@@ -0,0 +1,4 @@
qrcode>=7.4
numpy>=1.24
opencv-python>=4.8
pyzbar>=0.1.9
+4 -1
View File
@@ -4,14 +4,17 @@ from pathlib import Path
root = Path(__file__).resolve().parent root = Path(__file__).resolve().parent
scripts = [ scripts = [
'protocol_selftest.py', 'protocol_selftest.py',
'optical_image_decode_selftest.py',
'pairing_selftest.py', 'pairing_selftest.py',
'parallel_upload_selftest.py', 'parallel_upload_selftest.py',
'udp_discovery_selftest.py', 'udp_discovery_selftest.py',
'local_transfer_integration_selftest.py', 'local_transfer_integration_selftest.py',
'memory_budget_selftest.py', 'memory_budget_selftest.py',
'android_compat_selftest.py', 'android_compat_selftest.py',
'single_channel_guard_selftest.py',
'kotlin_host_smoke.py',
] ]
for name in scripts: for name in scripts:
print(f'== {name} ==', flush=True) print(f'== {name} ==', flush=True)
subprocess.run([sys.executable, str(root/name)], check=True) subprocess.run([sys.executable, str(root/name)], check=True)
print('ALL CORE PYTHON SELFTESTS PASSED') print('ALL HOST SELFTESTS PASSED')
+23
View File
@@ -0,0 +1,23 @@
#!/usr/bin/env python3
from pathlib import Path
ROOT=Path(__file__).resolve().parents[1]
main=(ROOT/'windows/src/main.rs').read_text()
cache=(ROOT/'windows/src/optical_cache.rs').read_text()
qr=(ROOT/'windows/src/qr.rs').read_text()
protocol=(ROOT/'windows/src/protocol.rs').read_text()
base45=(ROOT/'windows/src/base45.rs').read_text()
analyzer=(ROOT/'android/app/src/main/java/com/qft/optical/QrAnalyzer.kt').read_text()
android_protocol=(ROOT/'android/app/src/main/java/com/qft/optical/Protocol.kt').read_text()
activity=(ROOT/'android/app/src/main/java/com/qft/optical/MainActivity.kt').read_text()
assert 'render_qr_grid' not in qr+cache+main
assert 'self.optical.lanes' not in main
assert 'OPTICAL_MULTI' not in analyzer
assert 'newFixedThreadPool' not in analyzer
assert 'DEFAULT_CHUNK_SIZE: u16 = 450' in main
assert 'source.text_frame(page_index)' in cache and 'render_qr_fitted' in cache
assert 'QFT2:' in protocol and 'base45::encode' in protocol and 'EcLevel::L' in qr
assert 'Base45.decode' in android_protocol and 'QFT2' in android_protocol
assert 'assembler.acceptText(code.text)' in activity and 'acceptBinary' not in activity
assert 'grayBuffer.capture(image, current)' in analyzer and 'fingerprint = text.hashCode()' in analyzer
assert 'BB8' in base45 and 'UJCLQE7W581' in base45
print('PASS single-channel guard: one large QFT2/Base45 QR, 450B chunks, no 2x2/4-lane path, Android locked-ROI text decode only')
+1 -1
View File
@@ -2587,7 +2587,7 @@ checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
[[package]] [[package]]
name = "qft-windows" name = "qft-windows"
version = "0.3.0" version = "0.4.0-rc2"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"base64", "base64",
+1 -1
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "qft-windows" name = "qft-windows"
version = "0.3.0" version = "0.4.0-rc2"
edition = "2024" edition = "2024"
rust-version = "1.95" rust-version = "1.95"
+37
View File
@@ -0,0 +1,37 @@
const ALPHABET: &[u8; 45] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
/// RFC 9285 Base45. Its alphabet is fully supported by QR alphanumeric mode,
/// so the QR encoder can use fewer modules than Base64 text for the same
/// binary QFT frame while still giving Android a normal Result.text string.
pub fn encode(input: &[u8]) -> String {
if input.is_empty() {
return String::new();
}
let mut out = String::with_capacity((input.len() * 3 + 1) / 2);
let mut i = 0usize;
while i + 1 < input.len() {
let value = input[i] as usize * 256 + input[i + 1] as usize;
out.push(ALPHABET[value % 45] as char);
out.push(ALPHABET[(value / 45) % 45] as char);
out.push(ALPHABET[value / (45 * 45)] as char);
i += 2;
}
if i < input.len() {
let value = input[i] as usize;
out.push(ALPHABET[value % 45] as char);
out.push(ALPHABET[value / 45] as char);
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn known_vectors() {
assert_eq!(encode(b"AB"), "BB8");
assert_eq!(encode(b"Hello!!"), "%69 VD92EX0");
assert_eq!(encode(b"base-45"), "UJCLQE7W581");
}
}
+160 -92
View File
@@ -1,3 +1,4 @@
mod base45;
mod direct_ap; mod direct_ap;
mod optical_cache; mod optical_cache;
mod pairing; mod pairing;
@@ -16,9 +17,9 @@ use std::{
time::{Duration, Instant}, time::{Duration, Instant},
}; };
const DEFAULT_CHUNK_SIZE: u16 = 900; const DEFAULT_CHUNK_SIZE: u16 = 450;
const UI_FONT_NAME: &str = "qft-ui"; const UI_FONT_NAME: &str = "qft-ui";
const APP_VERSION: &str = "0.3.0-rc3"; const APP_VERSION: &str = "0.4.0-rc2";
fn main() -> eframe::Result { fn main() -> eframe::Result {
let options = eframe::NativeOptions { let options = eframe::NativeOptions {
@@ -50,8 +51,11 @@ struct OpticalState {
round: u64, round: u64,
playing: bool, playing: bool,
fps: f32, fps: f32,
lanes: usize,
cache_mib: usize, cache_mib: usize,
control_width: f32,
qr_zoom: f32,
focus_qr: bool,
advanced_open: bool,
last_advance: Instant, last_advance: Instant,
fps_window_started: Instant, fps_window_started: Instant,
displayed_in_window: u32, displayed_in_window: u32,
@@ -105,14 +109,17 @@ impl QftApp {
page_index: 0, page_index: 0,
round: 0, round: 0,
playing: false, playing: false,
fps: 60.0, fps: 45.0,
lanes: 4, cache_mib: 256,
cache_mib: 384, control_width: 330.0,
qr_zoom: 1.0,
focus_qr: false,
advanced_open: false,
last_advance: Instant::now(), last_advance: Instant::now(),
fps_window_started: Instant::now(), fps_window_started: Instant::now(),
displayed_in_window: 0, displayed_in_window: 0,
actual_page_fps: 0.0, actual_page_fps: 0.0,
status: "选择文件后开始光学发送。默认 4 码/页 · 60 FPS,缓存不足时会自动停在当前页等待。".into(), status: "选择文件后开始光学发送。v0.4 使用单个大二维码 + QFT2/Base45 低密度 450B 数据块,优先提高 Android 有效识别率。".into(),
}, },
receive: ReceiveState { receive: ReceiveState {
save_dir: None, save_dir: None,
@@ -209,118 +216,180 @@ impl QftApp {
self.optical.last_advance = Instant::now(); self.optical.last_advance = Instant::now();
self.optical_advance(ctx); self.optical_advance(ctx);
} }
// Keep the UI scheduler hot enough for a 60 Hz display without busy-spinning.
ctx.request_repaint_after((interval / 3).max(Duration::from_millis(1))); ctx.request_repaint_after((interval / 3).max(Duration::from_millis(1)));
} }
ui.horizontal_wrapped(|ui| { ui.horizontal_wrapped(|ui| {
ui.heading("电脑 → Android · 光学极速模式"); ui.heading("电脑 → Android · 单码锁定极速模式");
ui.separator(); ui.separator();
ui.label("屏幕 → 摄像头 · 0 网络"); ui.label("屏幕 → 摄像头 · 0 网络");
ui.separator();
if ui.button(if self.optical.focus_qr { "退出专注二维码" } else { "专注二维码" }).clicked() {
self.optical.focus_qr = !self.optical.focus_qr;
}
}); });
ui.add_space(8.0); ui.add_space(8.0);
ui.group(|ui| { if self.optical.focus_qr {
ui.horizontal_wrapped(|ui| { ui.horizontal_wrapped(|ui| {
if ui.button("选择文件").clicked() { self.optical_pick_file(ctx); } let enabled = self.optical.source.is_some();
ui.label("刷新率"); if ui.add_enabled(enabled, egui::Button::new(if self.optical.playing { "暂停" } else { "播放" })).clicked() {
ui.add(egui::Slider::new(&mut self.optical.fps, 1.0..=60.0).suffix(" FPS").step_by(1.0)); if !self.optical.playing && self.optical.prefetch.is_none() { self.restart_optical_pipeline(); }
if ui.small_button("15").clicked() { self.optical.fps = 15.0; }
if ui.small_button("30").clicked() { self.optical.fps = 30.0; }
if ui.small_button("60").clicked() { self.optical.fps = 60.0; }
if ui.small_button("极速预设").clicked() {
self.optical.fps = 60.0;
self.optical.lanes = 4;
self.optical.cache_mib = 384;
self.optical.playing = false;
self.restart_optical_pipeline();
let _ = self.optical_render_first(ctx);
}
});
let old_lanes = self.optical.lanes;
let old_cache = self.optical.cache_mib;
ui.horizontal_wrapped(|ui| {
ui.label("视觉并行");
ui.radio_value(&mut self.optical.lanes, 1, "1 码/页 · 兼容");
ui.radio_value(&mut self.optical.lanes, 4, "4 码/页 · 极速");
ui.separator();
ui.label("预编码缓存");
ui.add(egui::Slider::new(&mut self.optical.cache_mib, 64..=optical_cache::MAX_MANAGED_CACHE_MIB)
.suffix(" MiB").step_by(64.0));
});
ui.small(format!(
"QFT 只允许预编码缓存使用最多 {} MiB,为进程/GPU/系统缓冲预留空间,目标整进程不超过约 {} MiB。",
optical_cache::MAX_MANAGED_CACHE_MIB, optical_cache::HARD_PROCESS_BUDGET_MIB
));
if old_lanes != self.optical.lanes || old_cache != self.optical.cache_mib {
self.optical.playing = false;
self.restart_optical_pipeline();
let _ = self.optical_render_first(ctx);
}
let enabled = self.optical.source.is_some();
ui.horizontal_wrapped(|ui| {
if ui.add_enabled(enabled, egui::Button::new(if self.optical.playing { "暂停" } else { "开始播放" })).clicked() {
if !self.optical.playing && self.optical.prefetch.is_none() {
self.restart_optical_pipeline();
}
self.optical.playing = !self.optical.playing; self.optical.playing = !self.optical.playing;
self.optical.last_advance = Instant::now(); self.optical.last_advance = Instant::now();
self.optical.fps_window_started = Instant::now(); self.optical.fps_window_started = Instant::now();
self.optical.displayed_in_window = 0; self.optical.displayed_in_window = 0;
} }
if ui.add_enabled(enabled, egui::Button::new("回到第 1 页")).clicked() { ui.label(format!("{:.0} FPS", self.optical.fps));
ui.add(egui::Slider::new(&mut self.optical.qr_zoom, 0.65..=1.0).text("二维码占比").show_value(false));
ui.small("控制区已收起,尽可能把屏幕面积留给二维码");
});
ui.separator();
self.optical_qr_panel(ui);
return;
}
let available = ui.available_size();
let min_qr_width = 360.0_f32.min(available.x * 0.55);
let max_control = (available.x - min_qr_width - 12.0).max(240.0);
self.optical.control_width = self.optical.control_width.clamp(240.0, max_control);
let split_height = ui.available_height().max(420.0);
ui.horizontal(|ui| {
ui.allocate_ui_with_layout(
egui::vec2(self.optical.control_width, split_height),
egui::Layout::top_down(egui::Align::Min),
|ui| {
egui::ScrollArea::vertical().show(ui, |ui| {
self.optical_controls(ui, ctx);
});
},
);
let (bar_rect, bar_response) = ui.allocate_exact_size(
egui::vec2(8.0, split_height),
egui::Sense::drag(),
);
let bar_color = if bar_response.dragged() || bar_response.hovered() {
ui.visuals().widgets.active.bg_fill
} else {
ui.visuals().widgets.inactive.bg_fill
};
ui.painter().rect_filled(bar_rect.shrink2(egui::vec2(2.0, 0.0)), 3.0, bar_color);
if bar_response.dragged() {
let dx = ui.input(|i| i.pointer.delta().x);
self.optical.control_width = (self.optical.control_width + dx).clamp(240.0, max_control);
ctx.request_repaint();
}
bar_response.on_hover_text("拖动压缩/展开控制区,右侧二维码会自动放大");
ui.allocate_ui_with_layout(
egui::vec2(ui.available_width(), split_height),
egui::Layout::top_down(egui::Align::Center),
|ui| self.optical_qr_panel(ui),
);
});
}
fn optical_controls(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
ui.group(|ui| {
ui.heading("发送控制");
ui.horizontal_wrapped(|ui| {
if ui.button("选择文件").clicked() { self.optical_pick_file(ctx); }
let enabled = self.optical.source.is_some();
if ui.add_enabled(enabled, egui::Button::new(if self.optical.playing { "暂停" } else { "开始播放" })).clicked() {
if !self.optical.playing && self.optical.prefetch.is_none() { self.restart_optical_pipeline(); }
self.optical.playing = !self.optical.playing;
self.optical.last_advance = Instant::now();
self.optical.fps_window_started = Instant::now();
self.optical.displayed_in_window = 0;
}
if ui.add_enabled(enabled, egui::Button::new("回到第1帧")).clicked() {
self.optical.playing = false; self.optical.playing = false;
self.restart_optical_pipeline(); self.restart_optical_pipeline();
let _ = self.optical_render_first(ctx); let _ = self.optical_render_first(ctx);
} }
}); });
ui.add_space(6.0);
ui.label("显示刷新率");
ui.add(egui::Slider::new(&mut self.optical.fps, 5.0..=60.0).suffix(" FPS").step_by(1.0));
ui.horizontal_wrapped(|ui| {
if ui.small_button("稳定 30").clicked() { self.optical.fps = 30.0; }
if ui.small_button("平衡 45").clicked() { self.optical.fps = 45.0; }
if ui.small_button("最高 60").clicked() { self.optical.fps = 60.0; }
});
ui.small("Android 会先全屏搜索一次,然后锁定单个二维码区域进行局部高频解码;60 FPS 是显示目标,实际有效识别率由手机相机决定。");
}); });
ui.add_space(8.0);
ui.group(|ui| {
ui.heading("二维码可读性");
ui.label(format!("单码 · 每块 {} B · QFT2/Base45 · QR-L · 完整静区", DEFAULT_CHUNK_SIZE));
ui.add(egui::Slider::new(&mut self.optical.qr_zoom, 0.65..=1.0).text("画面占比"));
ui.small("v0.4 已彻底删除 4 码模式;QFT2 使用 Base45 让 QR 进入字母数字模式,比旧 Base64 文本更低密度。默认 450 B 数据块仍保持较低 QR 版本,让 Android 更容易稳定锁定。");
});
ui.add_space(8.0);
ui.checkbox(&mut self.optical.advanced_open, "高级设置");
if self.optical.advanced_open {
ui.group(|ui| {
let old_cache = self.optical.cache_mib;
ui.label("预编码缓存");
ui.add(egui::Slider::new(&mut self.optical.cache_mib, 64..=optical_cache::MAX_MANAGED_CACHE_MIB)
.suffix(" MiB").step_by(64.0));
ui.small(format!(
"托管缓存最多 {} MiB;整进程设计预算约 {} MiB。缓存只影响二维码预编码是否跟得上,不会把整个文件读进内存。",
optical_cache::MAX_MANAGED_CACHE_MIB, optical_cache::HARD_PROCESS_BUDGET_MIB
));
if old_cache != self.optical.cache_mib {
self.optical.playing = false;
self.restart_optical_pipeline();
let _ = self.optical_render_first(ctx);
}
});
}
ui.add_space(8.0); ui.add_space(8.0);
if let Some(source) = self.optical.source.as_ref() { if let Some(source) = self.optical.source.as_ref() {
let m = &source.manifest; let m = &source.manifest;
let pages = source.total_pages(self.optical.lanes); let pages = source.total_playlist_frames().max(1);
let logical_fps = self.optical.fps as f64 * self.optical.lanes as f64; let payload_rate = self.optical.fps as f64 * m.chunk_size as f64;
let payload_rate = logical_fps * m.chunk_size as f64; ui.group(|ui| {
ui.columns(3, |cols| { ui.small("实时状态");
cols[0].group(|ui| { ui.heading(format!("{:.1} 页/s", self.optical.actual_page_fps));
ui.small("传输"); ui.label(format!("理论载荷 ≈ {}/s", human_bytes(payload_rate as u64)));
ui.heading(format!("{:.0} FPS", self.optical.fps)); let cap = self.optical.prefetch.as_ref().map(|p| p.capacity_pages).unwrap_or(0);
ui.label(format!("{} 码/页 · {:.0} 逻辑帧/s", self.optical.lanes, logical_fps)); let page_mib = self.optical.prefetch.as_ref().map(|p| p.estimated_page_mib).unwrap_or(0.0);
}); ui.small(format!("预编码缓存:{} MiB · 最多 {cap} 帧 · {page_mib:.1} MiB/帧", self.optical.cache_mib));
cols[1].group(|ui| { ui.separator();
ui.small("实测显示"); ui.label(format!("设备:{} → Android", m.sender_device));
ui.heading(format!("{:.1} 页/s", self.optical.actual_page_fps)); ui.label(format!("文件:{} · {}", m.file_name, human_bytes(m.file_size)));
ui.label(format!("理论载荷 ≈ {}/s", human_bytes(payload_rate as u64))); ui.label(format!("帧:{}/{} · 完整轮次:{}", self.optical.page_index + 1, pages, self.optical.round));
}); ui.small(format!("SHA-256:{}", hex_sha256(&m.sha256)));
cols[2].group(|ui| {
ui.small("内存策略");
ui.heading(format!("{} MiB", self.optical.cache_mib));
let cap = self.optical.prefetch.as_ref().map(|p| p.capacity_pages).unwrap_or(0);
let page_mib = self.optical.prefetch.as_ref().map(|p| p.estimated_page_mib).unwrap_or(0.0);
ui.label(format!("预编码最多 {cap} 页 · {page_mib:.1} MiB/页 · 定位读取"));
});
}); });
ui.add_space(6.0);
ui.label(format!("传输设备:{} → Android 光学接收端", m.sender_device));
ui.label(format!("文件:{} · {}", m.file_name, human_bytes(m.file_size)));
ui.small(format!("源路径:{}", source.path().display()));
ui.label(format!("数据块:{} · 当前页:{}/{} · 完整轮次:{}", m.total_chunks, self.optical.page_index + 1, pages, self.optical.round));
ui.small(format!("SHA-256:{}", hex_sha256(&m.sha256)));
} }
ui.add_space(6.0);
ui.label(&self.optical.status); ui.label(&self.optical.status);
ui.separator(); }
fn optical_qr_panel(&mut self, ui: &mut egui::Ui) {
if let Some(texture) = &self.optical.texture { if let Some(texture) = &self.optical.texture {
let avail = ui.available_size(); let avail = ui.available_size();
let side = avail.x.min(avail.y).min(680.0).max(320.0); let reserved = if self.optical.focus_qr { 4.0 } else { 28.0 };
ui.vertical_centered(|ui| { ui.image((texture.id(), egui::vec2(side, side))); }); let base = avail.x.min((avail.y - reserved).max(220.0)).max(220.0);
let side = (base * self.optical.qr_zoom).clamp(220.0, base);
ui.vertical_centered(|ui| {
ui.image((texture.id(), egui::vec2(side, side)));
if !self.optical.focus_qr {
ui.small("拖动左侧分隔条可继续放大二维码;也可点击顶部“专注二维码”占满可用区域。");
}
});
} else { } else {
ui.vertical_centered(|ui| { ui.vertical_centered(|ui| {
ui.add_space(100.0); ui.add_space(120.0);
ui.heading("请选择一个文件"); ui.heading("请选择一个文件");
ui.label("极速模式会在后台并行预编码二维码;手机仍可处于飞行模式。") ui.label("单个大二维码会在这里显示,Android 识别后自动锁定区域。");
}); });
} }
} }
@@ -437,7 +506,7 @@ impl QftApp {
if let Err(e) = self.optical_render_first(ctx) { if let Err(e) = self.optical_render_first(ctx) {
self.optical.status = format!("生成二维码失败:{e:#}"); self.optical.status = format!("生成二维码失败:{e:#}");
} else { } else {
self.optical.status = "文件已载入。默认 4 码/页 · 60 FPS;低端手机若有效 QR/s 明显偏低,可降到 30 FPS。".into(); self.optical.status = "文件已载入。默认单个大二维码 · QFT2/Base45 450B 数据块 · 45 FPS;可按手机能力切到 30 或 60 FPS。".into();
} }
} }
Err(e) => self.optical.status = format!("读取文件失败:{e:#}"), Err(e) => self.optical.status = format!("读取文件失败:{e:#}"),
@@ -445,7 +514,7 @@ impl QftApp {
} }
fn optical_canvas_side(&self) -> usize { fn optical_canvas_side(&self) -> usize {
if self.optical.lanes == 4 { 960 } else { 760 } 1024
} }
fn restart_optical_pipeline(&mut self) { fn restart_optical_pipeline(&mut self) {
@@ -455,7 +524,6 @@ impl QftApp {
let Some(source) = self.optical.source.clone() else { return }; let Some(source) = self.optical.source.clone() else { return };
self.optical.prefetch = Some(OpticalPrefetcher::start( self.optical.prefetch = Some(OpticalPrefetcher::start(
source, source,
self.optical.lanes,
self.optical_canvas_side(), self.optical_canvas_side(),
self.optical.cache_mib, self.optical.cache_mib,
)); ));
@@ -463,8 +531,8 @@ impl QftApp {
fn optical_render_first(&mut self, ctx: &egui::Context) -> anyhow::Result<()> { fn optical_render_first(&mut self, ctx: &egui::Context) -> anyhow::Result<()> {
let Some(source) = self.optical.source.as_ref() else { return Ok(()) }; let Some(source) = self.optical.source.as_ref() else { return Ok(()) };
let texts = source.text_page(0, self.optical.lanes)?; let text = source.text_frame(0)?;
let image = qr::render_qr_grid(&texts, self.optical_canvas_side())?; let image = qr::render_qr_fitted(&text, self.optical_canvas_side())?;
self.set_optical_texture(ctx, image); self.set_optical_texture(ctx, image);
self.optical.page_index = 0; self.optical.page_index = 0;
self.optical.round = 0; self.optical.round = 0;
@@ -507,7 +575,7 @@ impl QftApp {
self.optical.status = if self.optical.actual_page_fps + 3.0 < self.optical.fps as f64 && self.optical.actual_page_fps > 1.0 { self.optical.status = if self.optical.actual_page_fps + 3.0 < self.optical.fps as f64 && self.optical.actual_page_fps > 1.0 {
"实际页面速率低于目标:可降低 FPS 或把缓存调高;文件数据仍会循环补帧。".into() "实际页面速率低于目标:可降低 FPS 或把缓存调高;文件数据仍会循环补帧。".into()
} else { } else {
"正在光学发送 · 4 码模式会把一页拆成四个独立 QR 并行解码。".into() "正在光学发送 · 单个大二维码,Android 锁定后仅在二维码 ROI 内高频解码。".into()
}; };
} }
Err(std::sync::mpsc::TryRecvError::Empty) => { Err(std::sync::mpsc::TryRecvError::Empty) => {
+7 -13
View File
@@ -11,14 +11,12 @@ use std::{
time::Duration, time::Duration,
}; };
/// Keep the managed pre-render cache comfortably below the user's 1.1 GiB /// Managed pre-render cache stays below the requested whole-process ceiling.
/// whole-process ceiling. egui, GPU staging, Rust stacks and OS buffers still
/// need headroom, so QFT never intentionally reserves the entire 1.1 GiB.
pub const HARD_PROCESS_BUDGET_MIB: usize = 1100; pub const HARD_PROCESS_BUDGET_MIB: usize = 1100;
pub const MAX_MANAGED_CACHE_MIB: usize = 768; pub const MAX_MANAGED_CACHE_MIB: usize = 768;
const MIN_CACHE_MIB: usize = 64; const MIN_CACHE_MIB: usize = 64;
const MAX_CACHE_PAGES: usize = 192; const MAX_CACHE_PAGES: usize = 192;
const PREENCODE_BATCH: usize = 8; const PREENCODE_BATCH: usize = 12;
pub struct EncodedPage { pub struct EncodedPage {
pub page_index: u32, pub page_index: u32,
@@ -38,12 +36,10 @@ pub struct OpticalPrefetcher {
impl OpticalPrefetcher { impl OpticalPrefetcher {
pub fn start( pub fn start(
source: Arc<TransferSource>, source: Arc<TransferSource>,
lanes: usize,
canvas_side: usize, canvas_side: usize,
requested_cache_mib: usize, requested_cache_mib: usize,
) -> Self { ) -> Self {
let cache_mib = requested_cache_mib.clamp(MIN_CACHE_MIB, MAX_MANAGED_CACHE_MIB); let cache_mib = requested_cache_mib.clamp(MIN_CACHE_MIB, MAX_MANAGED_CACHE_MIB);
// ColorImage uses Color32 pixels: approximately four bytes per pixel.
let bytes_per_page = canvas_side.saturating_mul(canvas_side).saturating_mul(4).max(1); let bytes_per_page = canvas_side.saturating_mul(canvas_side).saturating_mul(4).max(1);
let budget_bytes = cache_mib.saturating_mul(1024 * 1024); let budget_bytes = cache_mib.saturating_mul(1024 * 1024);
let capacity_pages = (budget_bytes / bytes_per_page).clamp(4, MAX_CACHE_PAGES); let capacity_pages = (budget_bytes / bytes_per_page).clamp(4, MAX_CACHE_PAGES);
@@ -52,11 +48,10 @@ impl OpticalPrefetcher {
let stop = Arc::new(AtomicBool::new(false)); let stop = Arc::new(AtomicBool::new(false));
let stop_worker = stop.clone(); let stop_worker = stop.clone();
// Render several consecutive pages in one Rayon batch. At 4 QR/page this // Single QR on screen, but multiple *future frames* are encoded in
// lets all CPU cores work across both pages and QR lanes and is much more // parallel so the display thread can still target 60 Hz.
// likely to keep a 60 Hz presentation queue full than a single-page loop.
let thread = thread::spawn(move || { let thread = thread::spawn(move || {
let total_pages = source.total_pages(lanes).max(1); let total_pages = source.total_playlist_frames().max(1);
let mut next_page = 0u32; let mut next_page = 0u32;
let mut next_round = 0u64; let mut next_round = 0u64;
while !stop_worker.load(Ordering::Relaxed) { while !stop_worker.load(Ordering::Relaxed) {
@@ -74,8 +69,8 @@ impl OpticalPrefetcher {
.into_par_iter() .into_par_iter()
.filter_map(|(order, page_index, round)| { .filter_map(|(order, page_index, round)| {
if stop_worker.load(Ordering::Relaxed) { return None; } if stop_worker.load(Ordering::Relaxed) { return None; }
let texts = source.text_page(page_index, lanes).ok()?; let text = source.text_frame(page_index).ok()?;
let image = qr::render_qr_grid(&texts, canvas_side).ok()?; let image = qr::render_qr_fitted(&text, canvas_side).ok()?;
Some((order, EncodedPage { page_index, round, image })) Some((order, EncodedPage { page_index, round, image }))
}) })
.collect(); .collect();
@@ -86,7 +81,6 @@ impl OpticalPrefetcher {
continue; continue;
} }
// Reorder the parallel batch explicitly before queueing.
for (_, mut item) in rendered { for (_, mut item) in rendered {
loop { loop {
match tx.try_send(item) { match tx.try_send(item) {
+29 -49
View File
@@ -1,8 +1,7 @@
use crate::base45;
use anyhow::{bail, Context, Result}; use anyhow::{bail, Context, Result};
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
use crc32fast::hash as crc32; use crc32fast::hash as crc32;
use rand::RngCore; use rand::RngCore;
use rayon::prelude::*;
use sha2::{Digest, Sha256}; use sha2::{Digest, Sha256};
use std::{ use std::{
fs::File, fs::File,
@@ -10,8 +9,8 @@ use std::{
path::{Path, PathBuf}, path::{Path, PathBuf},
}; };
pub const PREFIX: &str = "QFT1:"; pub const PREFIX: &str = "QFT2:";
pub const VERSION: u8 = 1; pub const VERSION: u8 = 2;
#[derive(Clone, Copy, Debug)] #[derive(Clone, Copy, Debug)]
#[repr(u8)] #[repr(u8)]
@@ -55,12 +54,7 @@ impl TransferSource {
bail!("file requires too many chunks"); bail!("file requires too many chunks");
} }
// Keep a single read-only file handle and use positioned reads for each
// optical chunk. This avoids mapping/touching a multi-GB file into the
// process working set, so the bounded QR prefetch cache remains the
// dominant managed memory consumer.
let sha256 = hash_file_streaming(&file)?; let sha256 = hash_file_streaming(&file)?;
let mut rng = rand::rng(); let mut rng = rand::rng();
let session_id = rng.next_u64(); let session_id = rng.next_u64();
let file_name = path let file_name = path
@@ -93,43 +87,17 @@ impl TransferSource {
self.manifest.total_chunks.saturating_add(2) self.manifest.total_chunks.saturating_add(2)
} }
pub fn total_pages(&self, lanes: usize) -> u32 {
let lanes = lanes.max(1) as u32;
let frames = self.total_playlist_frames();
(frames + lanes - 1) / lanes
}
/// Returns 1..=4 QFT text frames for one visual page. QR encodes are generated
/// in parallel by rayon; file bytes are read with positioned reads so workers
/// do not contend on a shared seek cursor and large files are not memory-mapped.
pub fn text_page(&self, page_index: u32, lanes: usize) -> Result<Vec<String>> {
let lanes = lanes.clamp(1, 4);
let total = self.total_playlist_frames();
let start = page_index.saturating_mul(lanes as u32);
if start >= total {
bail!("page index out of range");
}
let indices: Vec<u32> = (0..lanes)
.map(|lane| start + lane as u32)
.filter(|idx| *idx < total)
.collect();
indices
.into_par_iter()
.map(|idx| self.text_frame(idx))
.collect()
}
/// playlist_index: 0=manifest, 1..=N=data, N+1=end /// playlist_index: 0=manifest, 1..=N=data, N+1=end
pub fn text_frame(&self, playlist_index: u32) -> Result<String> { pub fn binary_frame(&self, playlist_index: u32) -> Result<Vec<u8>> {
let n = self.manifest.total_chunks; let n = self.manifest.total_chunks;
if playlist_index == 0 { if playlist_index == 0 {
return Ok(encode_manifest(&self.manifest)); return Ok(encode_manifest_binary(&self.manifest));
} }
if playlist_index >= 1 && playlist_index <= n { if playlist_index >= 1 && playlist_index <= n {
return self.encode_data(playlist_index - 1); return self.encode_data_binary(playlist_index - 1);
} }
if playlist_index == n + 1 { if playlist_index == n + 1 {
return Ok(encode_frame( return Ok(encode_frame_binary(
FrameKind::End, FrameKind::End,
self.manifest.session_id, self.manifest.session_id,
0, 0,
@@ -140,7 +108,15 @@ impl TransferSource {
bail!("playlist index out of range") bail!("playlist index out of range")
} }
fn encode_data(&self, seq: u32) -> Result<String> { /// QFT2 uses Base45 because the whole alphabet is legal in QR alphanumeric
/// mode. This is close to raw byte efficiency without relying on ZXing's
/// rawBytes interpretation, and Android can consume Result.text directly.
pub fn text_frame(&self, playlist_index: u32) -> Result<String> {
let binary = self.binary_frame(playlist_index)?;
Ok(format!("{PREFIX}{}", base45::encode(&binary)))
}
fn encode_data_binary(&self, seq: u32) -> Result<Vec<u8>> {
let offset = seq as u64 * self.manifest.chunk_size as u64; let offset = seq as u64 * self.manifest.chunk_size as u64;
let remaining = self.manifest.file_size.saturating_sub(offset); let remaining = self.manifest.file_size.saturating_sub(offset);
let len = remaining.min(self.manifest.chunk_size as u64) as usize; let len = remaining.min(self.manifest.chunk_size as u64) as usize;
@@ -148,7 +124,7 @@ impl TransferSource {
if len > 0 { if len > 0 {
read_exact_at(&self.file, &mut payload, offset)?; read_exact_at(&self.file, &mut payload, offset)?;
} }
Ok(encode_frame( Ok(encode_frame_binary(
FrameKind::Data, FrameKind::Data,
self.manifest.session_id, self.manifest.session_id,
seq, seq,
@@ -158,7 +134,7 @@ impl TransferSource {
} }
} }
fn encode_manifest(m: &Manifest) -> String { fn encode_manifest_binary(m: &Manifest) -> Vec<u8> {
let name = m.file_name.as_bytes(); let name = m.file_name.as_bytes();
let name_len = name.len().min(u16::MAX as usize) as u16; let name_len = name.len().min(u16::MAX as usize) as u16;
let device = m.sender_device.as_bytes(); let device = m.sender_device.as_bytes();
@@ -173,7 +149,7 @@ fn encode_manifest(m: &Manifest) -> String {
payload.extend_from_slice(&name[..name_len as usize]); payload.extend_from_slice(&name[..name_len as usize]);
payload.extend_from_slice(&device_len.to_be_bytes()); payload.extend_from_slice(&device_len.to_be_bytes());
payload.extend_from_slice(&device[..device_len as usize]); payload.extend_from_slice(&device[..device_len as usize]);
encode_frame( encode_frame_binary(
FrameKind::Manifest, FrameKind::Manifest,
m.session_id, m.session_id,
0, 0,
@@ -182,16 +158,16 @@ fn encode_manifest(m: &Manifest) -> String {
) )
} }
pub fn encode_frame( pub fn encode_frame_binary(
kind: FrameKind, kind: FrameKind,
session_id: u64, session_id: u64,
seq: u32, seq: u32,
total_chunks: u32, total_chunks: u32,
payload: &[u8], payload: &[u8],
) -> String { ) -> Vec<u8> {
assert!(payload.len() <= u16::MAX as usize); assert!(payload.len() <= u16::MAX as usize);
let mut binary = Vec::with_capacity(28 + payload.len()); let mut binary = Vec::with_capacity(28 + payload.len());
binary.extend_from_slice(b"QFT1"); binary.extend_from_slice(b"QFT2");
binary.push(VERSION); binary.push(VERSION);
binary.push(kind as u8); binary.push(kind as u8);
binary.extend_from_slice(&session_id.to_be_bytes()); binary.extend_from_slice(&session_id.to_be_bytes());
@@ -201,7 +177,7 @@ pub fn encode_frame(
binary.extend_from_slice(payload); binary.extend_from_slice(payload);
let crc = crc32(&binary); let crc = crc32(&binary);
binary.extend_from_slice(&crc.to_be_bytes()); binary.extend_from_slice(&crc.to_be_bytes());
format!("{PREFIX}{}", URL_SAFE_NO_PAD.encode(binary)) binary
} }
pub fn hex_sha256(bytes: &[u8; 32]) -> String { pub fn hex_sha256(bytes: &[u8; 32]) -> String {
@@ -236,7 +212,9 @@ fn hash_file_streaming(file: &File) -> Result<[u8; 32]> {
let mut buf = vec![0u8; 4 * 1024 * 1024]; let mut buf = vec![0u8; 4 * 1024 * 1024];
loop { loop {
let n = input.read(&mut buf).context("read input for sha256")?; let n = input.read(&mut buf).context("read input for sha256")?;
if n == 0 { break; } if n == 0 {
break;
}
hasher.update(&buf[..n]); hasher.update(&buf[..n]);
} }
Ok(hasher.finalize().into()) Ok(hasher.finalize().into())
@@ -245,7 +223,9 @@ fn hash_file_streaming(file: &File) -> Result<[u8; 32]> {
fn read_exact_at(file: &File, mut out: &mut [u8], mut offset: u64) -> Result<()> { fn read_exact_at(file: &File, mut out: &mut [u8], mut offset: u64) -> Result<()> {
while !out.is_empty() { while !out.is_empty() {
let n = read_at_once(file, out, offset)?; let n = read_at_once(file, out, offset)?;
if n == 0 { bail!("unexpected EOF at offset {offset}"); } if n == 0 {
bail!("unexpected EOF at offset {offset}");
}
offset = offset.saturating_add(n as u64); offset = offset.saturating_add(n as u64);
let (_, rest) = out.split_at_mut(n); let (_, rest) = out.split_at_mut(n);
out = rest; out = rest;
+21 -77
View File
@@ -1,60 +1,22 @@
use anyhow::{Context, Result}; use anyhow::{Context, Result};
use eframe::egui::ColorImage; use eframe::egui::ColorImage;
use qrcode::{types::Color, EcLevel, QrCode}; use qrcode::{types::Color, EcLevel, QrCode};
use rayon::prelude::*;
const QUIET_MODULES: usize = 4; const QUIET_MODULES: usize = 4;
/// Render exact black/white pixels with an explicit quiet zone. /// Active optical renderer. QFT2/Base45 text uses only QR alphanumeric
pub fn render_qr(text: &str, scale: usize) -> Result<ColorImage> { /// characters, allowing the QR encoder to choose a compact alphanumeric data
/// mode. Exact integer module pixels + full quiet zone maximize camera clarity.
pub fn render_qr_fitted(text: &str, target_side: usize) -> Result<ColorImage> {
let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::L) let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::L)
.context("QR payload too large")?; .context("QR payload too large")?;
let modules = code.width(); let modules = code.width() + QUIET_MODULES * 2;
let scale = scale.max(1); let scale = (target_side / modules).max(1);
let side_modules = modules + QUIET_MODULES * 2; let side = modules * scale;
let side_px = side_modules * scale; Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side)))
let gray = render_code_gray(&code, side_px);
Ok(ColorImage::from_gray([side_px, side_px], &gray))
} }
/// Render 1..=4 independent QR symbols into one fixed-size optical page. /// Pairing QR stays static and uses M error correction for first-scan reliability.
/// A 2x2 page quadruples the number of logical QFT frames presented per
/// display refresh while keeping every symbol standards-compliant.
pub fn render_qr_grid(texts: &[String], canvas_side: usize) -> Result<ColorImage> {
let count = texts.len().clamp(1, 4);
if count == 1 {
return render_qr_fitted(&texts[0], canvas_side.max(320));
}
let canvas_side = canvas_side.max(640);
let gutter = (canvas_side / 64).clamp(12, 24);
let cell = (canvas_side - gutter * 3) / 2;
let rendered: Vec<(usize, Vec<u8>)> = texts[..count]
.par_iter()
.map(|text| render_qr_gray_fitted(text, cell))
.collect::<Result<Vec<_>>>()?;
let mut canvas = vec![255u8; canvas_side * canvas_side];
for (index, (side, gray)) in rendered.into_iter().enumerate() {
let col = index % 2;
let row = index / 2;
let cell_x = gutter + col * (cell + gutter);
let cell_y = gutter + row * (cell + gutter);
let x0 = cell_x + (cell.saturating_sub(side)) / 2;
let y0 = cell_y + (cell.saturating_sub(side)) / 2;
for y in 0..side {
let dst = (y0 + y) * canvas_side + x0;
let src = y * side;
canvas[dst..dst + side].copy_from_slice(&gray[src..src + side]);
}
}
Ok(ColorImage::from_gray([canvas_side, canvas_side], &canvas))
}
/// Pairing QR favors scan reliability over maximum capacity. QFTPAIR2 is kept
/// deliberately short, so medium error correction still yields a low-version
/// symbol that phones acquire faster at imperfect angles.
pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> { pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> {
let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::M) let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::M)
.context("pair QR payload too large")?; .context("pair QR payload too large")?;
@@ -64,38 +26,20 @@ pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> {
Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side))) Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side)))
} }
pub fn render_qr_fitted(text: &str, target_side: usize) -> Result<ColorImage> { fn render_code_gray(code: &QrCode, side: usize) -> Vec<u8> {
let (side, gray) = render_qr_gray_fitted(text, target_side)?; let qr_width = code.width();
Ok(ColorImage::from_gray([side, side], &gray)) let modules = qr_width + QUIET_MODULES * 2;
} let scale = (side / modules).max(1);
let actual_side = modules * scale;
fn render_qr_gray_fitted(text: &str, target_side: usize) -> Result<(usize, Vec<u8>)> {
let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::L)
.context("QR payload too large")?;
let modules = code.width() + QUIET_MODULES * 2;
let scale = (target_side / modules).max(1);
let side = modules * scale;
Ok((side, render_code_gray(&code, side)))
}
fn render_code_gray(code: &QrCode, side_px: usize) -> Vec<u8> {
let modules = code.width();
let side_modules = modules + QUIET_MODULES * 2;
let scale = (side_px / side_modules).max(1);
let actual_side = side_modules * scale;
let mut gray = vec![255u8; actual_side * actual_side]; let mut gray = vec![255u8; actual_side * actual_side];
let colors = code.to_colors(); for y in 0..qr_width {
for x in 0..qr_width {
for y in 0..modules { if code[(x, y)] != Color::Dark { continue; }
for x in 0..modules { let px0 = (x + QUIET_MODULES) * scale;
if colors[y * modules + x] != Color::Dark { let py0 = (y + QUIET_MODULES) * scale;
continue; for py in py0..py0 + scale {
}
let x0 = (x + QUIET_MODULES) * scale;
let y0 = (y + QUIET_MODULES) * scale;
for py in y0..y0 + scale {
let row = py * actual_side; let row = py * actual_side;
gray[row + x0..row + x0 + scale].fill(0); gray[row + px0..row + px0 + scale].fill(0);
} }
} }
} }