Personal Nix flake
nixos
home-manager
nix
feat: Enable experimental CanvasBio CB2000 libfprint patches
+5456
-36
-16
flake.lock
-16
flake.lock
···
1633
1633
"type": "github"
1634
1634
}
1635
1635
},
1636
-
"pkgs-by-name-for-flake-parts": {
1637
-
"locked": {
1638
-
"lastModified": 1769286518,
1639
-
"narHash": "sha256-F7VlUICvYp2wJKyQqM6d46BNEZCzMQ6dMH9zbmjuybc=",
1640
-
"owner": "drupol",
1641
-
"repo": "pkgs-by-name-for-flake-parts",
1642
-
"rev": "7ba1cd4a9a72c9c6c272018a63f090f2c912a171",
1643
-
"type": "github"
1644
-
},
1645
-
"original": {
1646
-
"owner": "drupol",
1647
-
"repo": "pkgs-by-name-for-flake-parts",
1648
-
"type": "github"
1649
-
}
1650
-
},
1651
1636
"poetry2nix": {
1652
1637
"inputs": {
1653
1638
"flake-utils": [
···
1814
1799
"nixpkgs-schemas": "nixpkgs-schemas",
1815
1800
"nixvim": "nixvim",
1816
1801
"nur": "nur",
1817
-
"pkgs-by-name-for-flake-parts": "pkgs-by-name-for-flake-parts",
1818
1802
"spicetify-nix": "spicetify-nix",
1819
1803
"stable": "stable",
1820
1804
"stylix": "stylix",
-1
flake.nix
-1
flake.nix
···
106
106
};
107
107
nix-std.url = "github:chessai/nix-std";
108
108
nur.url = "github:nix-community/NUR";
109
-
pkgs-by-name-for-flake-parts.url = "github:drupol/pkgs-by-name-for-flake-parts";
110
109
spicetify-nix = {
111
110
url = "github:Gerg-L/spicetify-nix";
112
111
inputs.nixpkgs.follows = "nixpkgs";
+1
-1
nix/lib/default.nix
+1
-1
nix/lib/default.nix
···
40
40
'';
41
41
nixFilesToAttrs = path:
42
42
builtins.readDir path
43
-
|> lib.filterAttrs (name: type: type == "regular" && name != "default.nix")
43
+
|> lib.filterAttrs (name: type: type == "regular" && lib.hasSuffix ".nix" name && name != "default.nix")
44
44
|> lib.concatMapAttrs (relativePath: _: {
45
45
${relativePath |> lib.removeSuffix ".nix"} = path + /${relativePath};
46
46
});
+7
-1
nix/nixos/profiles/formfactor/laptop.nix
+7
-1
nix/nixos/profiles/formfactor/laptop.nix
···
2
2
{
3
3
config,
4
4
lib,
5
+
pkgs,
5
6
...
6
7
}: let
7
8
cfg = config.my.profiles.formfactor.laptop;
···
26
27
};
27
28
};
28
29
};
29
-
fprintd.enable = true;
30
+
fprintd = {
31
+
enable = true;
32
+
package = pkgs.fprintd.override {
33
+
libfprint = pkgs.libfprint-canvasbio-cb2000;
34
+
};
35
+
};
30
36
thermald.enable = true;
31
37
};
32
38
};
+4
-4
nix/overlays/packages.nix
+4
-4
nix/overlays/packages.nix
+13
-13
nix/packages/default.nix
+13
-13
nix/packages/default.nix
···
1
-
{inputs, ...}: {
2
-
imports = [
3
-
inputs.pkgs-by-name-for-flake-parts.flakeModule
4
-
];
5
-
1
+
{...}: {
6
2
perSystem = {
7
3
inputs',
8
4
lib,
···
11
7
}: let
12
8
callPackage = lib.callPackageWith pkgs;
13
9
in {
14
-
pkgsDirectory = ./.;
15
-
pkgsNameSeparator = "-";
16
-
packages = lib.mkForce {
17
-
lichen =
18
-
callPackage
19
-
./lichen/package.nix
20
-
{inherit (inputs'.nixpkgs-hare.legacyPackages) hare hareHook;};
21
-
};
10
+
packages =
11
+
(lib.packagesFromDirectoryRecursive {
12
+
inherit callPackage;
13
+
directory = ./.;
14
+
}
15
+
|> lib.filterAttrs (name: _: name != "default"))
16
+
// {
17
+
lichen =
18
+
callPackage
19
+
./lichen/package.nix
20
+
{inherit (inputs'.nixpkgs-hare.legacyPackages) hare hareHook;};
21
+
};
22
22
};
23
23
}
+5425
nix/packages/libfprint-canvasbio-cb2000/001-add-canvasbio.patch
+5425
nix/packages/libfprint-canvasbio-cb2000/001-add-canvasbio.patch
···
1
+
diff --git a/libfprint/drivers/canvasbio_cb2000.c b/libfprint/drivers/canvasbio_cb2000.c
2
+
new file mode 100644
3
+
index 0000000..2492d32
4
+
--- /dev/null
5
+
+++ b/libfprint/drivers/canvasbio_cb2000.c
6
+
@@ -0,0 +1,5353 @@
7
+
+/*
8
+
+ * CanvasBio CB2000 Fingerprint Reader Driver for libfprint
9
+
+ *
10
+
+ * Copyright (C) 2025 CanvasMancer Project
11
+
+ * Based on protocol analysis from libfprint issue #509
12
+
+ * https://gitlab.freedesktop.org/libfprint/libfprint/-/issues/509
13
+
+ *
14
+
+ * This library is free software; you can redistribute it and/or
15
+
+ * modify it under the terms of the GNU Lesser General Public
16
+
+ * License as published by the Free Software Foundation; either
17
+
+ * version 2.1 of the License, or (at your option) any later version.
18
+
+ *
19
+
+ * ============================================================================
20
+
+ * DRIVER OVERVIEW
21
+
+ * ============================================================================
22
+
+ *
23
+
+ * DRIVER VERSION TAG: V44
24
+
+ * Keep this tag updated at every iteration to make runtime/source identification
25
+
+ * unambiguous across logs, backups and manual syncs.
26
+
+ *
27
+
+ * Current Linux implementation uses the host-side matching path (MoH behavior):
28
+
+ * the sensor captures a raw grayscale image, and libfprint performs minutiae
29
+
+ * extraction/matching. A runtime-gated skeleton hook exists for future
30
+
+ * device-assisted verify experiments without changing the default behavior.
31
+
+ *
32
+
+ * Device specifications:
33
+
+ * - Vendor ID: 0x2DF0 (CanvasBio)
34
+
+ * - Product IDs: 0x0003, 0x0007
35
+
+ * - Image size: 80x64 pixels (5120 bytes)
36
+
+ * - Interface: USB bulk transfers + vendor control requests
37
+
+ *
38
+
+ * Architecture: Master cycle SSM + sub-SSMs per phase.
39
+
+ * First cycle does USB reset + full activation. Subsequent cycles do soft rearm:
40
+
+ *
41
+
+ * HARD_RESET -> INIT_CONFIG -> SETTLE_DELAY -> WAIT_FINGER ->
42
+
+ * CAPTURE_START -> READ_IMAGE -> FINALIZE -> VERIFY_RESULT_STATUS ->
43
+
+ * VERIFY_READY_QUERY_A -> VERIFY_READY_QUERY_B -> VERIFY_READY_DECIDE ->
44
+
+ * SUBMIT_IMAGE ->
45
+
+ * WAIT_REMOVAL -> REARM -> [next cycle]
46
+
+ *
47
+
+ * ============================================================================
48
+
+ */
49
+
+
50
+
+#define FP_COMPONENT "canvasbio_cb2000"
51
+
+#define CB2000_DRIVER_VERSION_TAG "V44"
52
+
+
53
+
+#include "drivers_api.h"
54
+
+#include <stdio.h> /* For raw dump file operations */
55
+
+#include <time.h> /* For timestamp in filename */
56
+
+#include <string.h> /* For memcpy/strlen */
57
+
+#include <math.h> /* For sqrt() in NCC */
58
+
+#include <gio/gio.h>
59
+
+
60
+
+/* Raw dump configuration for stride debugging */
61
+
+#define CB2000_RAW_DUMP_ENABLED 1
62
+
+
63
+
+/* ============================================================================
64
+
+ * DEVICE CONSTANTS
65
+
+ * ============================================================================ */
66
+
+
67
+
+/* USB Vendor and Product IDs */
68
+
+#define CB2000_VID 0x2df0
69
+
+#define CB2000_PID_1 0x0003
70
+
+#define CB2000_PID_2 0x0007
71
+
+
72
+
+/* USB Endpoints */
73
+
+#define CB2000_EP_OUT 0x01
74
+
+#define CB2000_EP_IN 0x82
75
+
+
76
+
+/* Image dimensions */
77
+
+#define CB2000_IMG_WIDTH 80
78
+
+#define CB2000_IMG_HEIGHT 64
79
+
+#define CB2000_IMG_SIZE (CB2000_IMG_WIDTH * CB2000_IMG_HEIGHT)
80
+
+#define CB2000_IMG_CHUNKS 20
81
+
+#define CB2000_CHUNK_SIZE 320
82
+
+#define CB2000_CHUNK_PAYLOAD_SIZE 256
83
+
+#define CB2000_CHUNK_DEFAULT_PAYLOAD_OFFSET \
84
+
+ (CB2000_CHUNK_SIZE - CB2000_CHUNK_PAYLOAD_SIZE) /* 64 bytes */
85
+
+/* Approx. sensor size: 15mm x 9mm => ~6.22 px/mm average. */
86
+
+#define CB2000_PPMM_DEFAULT 13.39 /* ~340 dpi - actual sensor resolution */
87
+
+/* CLAHE tile size (80/10=8, 64/8=8 → 10x8 grid of 8x8 tiles) */
88
+
+#define CB2000_CLAHE_TILE_W 8
89
+
+#define CB2000_CLAHE_TILE_H 8
90
+
+#define CB2000_CLAHE_CLIP_LIMIT 3.0
91
+
+
92
+
+/* Timing constants (milliseconds) */
93
+
+#define CB2000_TIMEOUT 5000 /* USB transfer timeout */
94
+
+#define CB2000_POLL_INTERVAL 16 /* Windows parity: ~16ms REQ_POLL cadence */
95
+
+#define CB2000_WAKEUP_DELAY 500 /* Post-init stabilization delay */
96
+
+#define CB2000_REMOVAL_INTERVAL 175 /* Finger removal poll interval */
97
+
+
98
+
+/* Validation thresholds */
99
+
+#define CB2000_POLL_DEBOUNCE_COUNT 1
100
+
+#define CB2000_POLL_STALE_TIMEOUT_MS 12000 /* ~12s max wait for finger */
101
+
+#define CB2000_EARLY_PLACEMENT_POLLS 0 /* disabled (Windows parity) */
102
+
+#define CB2000_EARLY_PLACEMENT_DELAY_MS 400
103
+
+#define CB2000_REMOVAL_STABLE_OFF_COUNT 2
104
+
+#define CB2000_REMOVAL_STALE_TIMEOUT_MS 10000 /* ~10s max wait for removal */
105
+
+#define CB2000_MIN_IMAGE_VARIANCE 3000.0
106
+
+/* Background capture/quality heuristics */
107
+
+#define CB2000_BG_CAPTURE_MAX_VARIANCE 1800.0
108
+
+#define CB2000_BLOCK_SIZE 8
109
+
+#define CB2000_LOW_VAR_THRESHOLD 2000.0
110
+
+#define CB2000_LOW_VAR_RATIO_MAX 0.15
111
+
+/* Area thresholds per action (can be overridden by env). */
112
+
+#define CB2000_AREA_MIN_CAPTURE_PCT 85
113
+
+#define CB2000_AREA_MIN_ENROLL_PCT 70
114
+
+#define CB2000_AREA_MIN_VERIFY_PCT 70
115
+
+/* Focus (Laplacian variance) threshold to avoid very blurry frames */
116
+
+#define CB2000_MIN_FOCUS_VARIANCE 500.0
117
+
+/* Foreground threshold used for RE-style area/overlap heuristics. */
118
+
+#define CB2000_FOREGROUND_THRESHOLD 32
119
+
+/* Some PCAPs show an alternate detect value for reg 0x51. */
120
+
+#define CB2000_USE_ALT_DETECT_51 0
121
+
+
122
+
+/* NCC correlation matching */
123
+
+#define CB2000_NR_ENROLL_STAGES 5
124
+
+#define CB2000_NCC_MAX_SHIFT_DEFAULT 3
125
+
+#define CB2000_NCC_MASK_THRESHOLD_DEFAULT 24
126
+
+#define CB2000_NCC_MIN_SAMPLES_DEFAULT 700
127
+
+/*
128
+
+ * Default NCC thresholds tuned for tiny 80x64 captures.
129
+
+ * Keep multi-sample support enabled to avoid easy false accepts.
130
+
+ */
131
+
+#define CB2000_NCC_MATCH_TOP1_DEFAULT 0.40
132
+
+#define CB2000_NCC_MATCH_TOP2_DEFAULT 0.30
133
+
+#define CB2000_NCC_MATCH_MEAN3_DEFAULT 0.30
134
+
+#define CB2000_NCC_MATCH_GRAD1_DEFAULT 0.22
135
+
+#define CB2000_NCC_SUPPORT_MIN_DEFAULT 2
136
+
+#define CB2000_NCC_SUPPORT_INT_DEFAULT 0.28
137
+
+#define CB2000_NCC_SUPPORT_GRAD_DEFAULT 0.20
138
+
+/* Medium band for borderline same-finger attempts on tiny captures. */
139
+
+#define CB2000_NCC_MEDIUM_TOP1_DEFAULT 0.33
140
+
+#define CB2000_NCC_MEDIUM_TOP2_DEFAULT 0.27
141
+
+#define CB2000_NCC_MEDIUM_MEAN3_DEFAULT 0.24
142
+
+#define CB2000_NCC_MEDIUM_GRAD1_DEFAULT 0.20
143
+
+#define CB2000_NCC_MEDIUM_SUPPORT_MIN_DEFAULT 2
144
+
+/* Dominant-match band: high top1 with coherent mean/gradient and minimum support. */
145
+
+#define CB2000_NCC_DOMINANT_TOP1_DEFAULT 0.44
146
+
+#define CB2000_NCC_DOMINANT_TOP2_DEFAULT 0.20
147
+
+#define CB2000_NCC_DOMINANT_MEAN3_DEFAULT 0.24
148
+
+#define CB2000_NCC_DOMINANT_GRAD1_DEFAULT 0.24
149
+
+#define CB2000_NCC_DOMINANT_SUPPORT_MIN_DEFAULT 1
150
+
+/*
151
+
+ * Cross-sample consistency band:
152
+
+ * If at least 1 enrolled sample supports the captured frame,
153
+
+ * accept with lower per-score thresholds.
154
+
+ */
155
+
+#define CB2000_NCC_CONSISTENT_TOP1_DEFAULT 0.26
156
+
+#define CB2000_NCC_CONSISTENT_MEAN3_DEFAULT 0.20
157
+
+#define CB2000_NCC_CONSISTENT_GRAD1_DEFAULT 0.18
158
+
+#define CB2000_NCC_CONSISTENT_SUPPORT_MIN_DEFAULT 2
159
+
+#define CB2000_NCC_NOMATCH_TOP1_DEFAULT 0.22
160
+
+/*
161
+
+ * Single-strong band:
162
+
+ * allow MATCH when one enrolled sample is clearly strong and stable.
163
+
+ */
164
+
+#define CB2000_NCC_SINGLE_TOP1_DEFAULT 0.42
165
+
+#define CB2000_NCC_SINGLE_TOP2_DEFAULT 0.20
166
+
+#define CB2000_NCC_SINGLE_MEAN3_DEFAULT 0.24
167
+
+#define CB2000_NCC_SINGLE_GRAD1_DEFAULT 0.22
168
+
+#define CB2000_NCC_SINGLE_SUPPORT_MIN_DEFAULT 1
169
+
+/*
170
+
+ * Clear no-match band:
171
+
+ * avoid endless RETRY for clearly different fingers.
172
+
+ */
173
+
+#define CB2000_NCC_CLEAR_NOMATCH_TOP1_DEFAULT 0.25
174
+
+#define CB2000_NCC_CLEAR_NOMATCH_MEAN3_DEFAULT 0.17
175
+
+/* Adaptive thresholding based on enroll-template cohesion. */
176
+
+#define CB2000_NCC_ADAPTIVE_ENABLED_DEFAULT 1
177
+
+#define CB2000_NCC_ADAPTIVE_MAX_RELAX_DEFAULT 0.08
178
+
+#define CB2000_NCC_ADAPTIVE_TARGET_MEAN_DEFAULT 0.36
179
+
+#define CB2000_NCC_ADAPTIVE_TARGET_MIN_DEFAULT 0.28
180
+
+#define CB2000_NCC_ADAPTIVE_SUPPORT_RELAX_AT 0.045
181
+
+#define CB2000_NCC_ADAPTIVE_RELAX_SUPPORT_DEFAULT 0
182
+
+#define CB2000_PRINT_FORMAT "(uqq@ay)"
183
+
+
184
+
+/* ============================================================================
185
+
+ * USB CONTROL TRANSFER REQUESTS
186
+
+ * ============================================================================ */
187
+
+#define REQ_CONFIG 202 /* 0xCA */
188
+
+#define REQ_STATUS 204 /* 0xCC */
189
+
+#define REQ_POLL 218 /* 0xDA */
190
+
+#define REQ_INIT 219 /* 0xDB */
191
+
+
192
+
+#define CTRL_IN 0xC0
193
+
+#define CTRL_OUT 0x40
194
+
+
195
+
+/* ============================================================================
196
+
+ * STATE MACHINE DEFINITIONS
197
+
+ * ============================================================================
198
+
+ *
199
+
+ * Architecture: One master cycle SSM controls the full capture flow.
200
+
+ * Sub-SSMs handle individual phases (activation, polling, image read).
201
+
+ * All polling lives inside sub-SSMs - no external timers except settle delay.
202
+
+ */
203
+
+
204
+
+/* Master cycle SSM - one complete capture cycle */
205
+
+typedef enum {
206
+
+ CYCLE_RECOVERY, /* Explicit recovery state */
207
+
+ CYCLE_HARD_RESET, /* USB reset + reclaim interface */
208
+
+ CYCLE_INIT_CONFIG, /* Full activation via sub-SSM */
209
+
+ CYCLE_SETTLE_DELAY, /* Post-init stabilization timer */
210
+
+ CYCLE_WAIT_FINGER, /* Finger polling via sub-SSM */
211
+
+ CYCLE_EARLY_PLACEMENT_DELAY, /* Extra delay if finger too early */
212
+
+ CYCLE_CAPTURE_START, /* Capture start commands via sub-SSM */
213
+
+ CYCLE_READ_IMAGE, /* Image read (20 chunks) via sub-SSM */
214
+
+ CYCLE_FINALIZE, /* Capture finalize commands via sub-SSM */
215
+
+ CYCLE_VERIFY_RESULT_STATUS, /* Verify-only status/result routing */
216
+
+ CYCLE_VERIFY_READY_QUERY_A, /* Verify READY: complementary status query A */
217
+
+ CYCLE_VERIFY_READY_QUERY_B, /* Verify READY: complementary status query B */
218
+
+ CYCLE_VERIFY_READY_DECIDE, /* Verify READY: decide route from query */
219
+
+ CYCLE_SUBMIT_IMAGE, /* Submit image to libfprint */
220
+
+ CYCLE_WAIT_REMOVAL, /* Finger removal polling via sub-SSM */
221
+
+ CYCLE_REARM, /* Soft rearm between captures */
222
+
+ CYCLE_NUM_STATES,
223
+
+} CycleState;
224
+
+
225
+
+/* Sub-SSM: finger polling loop */
226
+
+typedef enum {
227
+
+ POLL_FINGER_DELAY, /* Wait 16ms */
228
+
+ POLL_FINGER_SEND, /* Submit REQ_POLL, callback decides */
229
+
+ POLL_FINGER_NUM,
230
+
+} PollFingerState;
231
+
+
232
+
+/* Sub-SSM: removal polling loop */
233
+
+typedef enum {
234
+
+ POLL_REMOVAL_DELAY, /* Wait 175ms */
235
+
+ POLL_REMOVAL_SEND, /* Submit REQ_POLL, callback decides */
236
+
+ POLL_REMOVAL_NUM,
237
+
+} PollRemovalState;
238
+
+
239
+
+/* Sub-SSM: image read (chunk + padding loop) */
240
+
+typedef enum {
241
+
+ IMG_READ_CHUNK, /* Bulk read 320 bytes */
242
+
+ IMG_WRITE_PADDING, /* Bulk write 256 zeros */
243
+
+ IMG_READ_NUM,
244
+
+} ImageReadState;
245
+
+
246
+
+/* Activation sub-SSM (existing, used by CYCLE_INIT_CONFIG) */
247
+
+typedef enum {
248
+
+ STATE_ACTIVATE_WAKE_SEQ,
249
+
+ STATE_ACTIVATE_REGS_SEQ,
250
+
+ STATE_ACTIVATE_TRIGGER_SEQ,
251
+
+ STATE_ACTIVATE_CAPTURE_SEQ,
252
+
+ STATE_ACTIVATE_FINALIZE_SEQ,
253
+
+ STATE_ACTIVATE_NUM_STATES,
254
+
+} ActivateState;
255
+
+
256
+
+/* ============================================================================
257
+
+ * COMMAND TABLE STRUCTURES
258
+
+ * ============================================================================ */
259
+
+
260
+
+typedef enum {
261
+
+ CMD_END = 0,
262
+
+ CMD_BULK_OUT,
263
+
+ CMD_BULK_IN,
264
+
+ CMD_CTRL_OUT,
265
+
+ CMD_CTRL_IN,
266
+
+} Cb2000CmdType;
267
+
+
268
+
+typedef struct {
269
+
+ Cb2000CmdType type;
270
+
+ guint8 request;
271
+
+ guint16 value;
272
+
+ guint16 index;
273
+
+ const guint8 *data;
274
+
+ gsize len;
275
+
+} Cb2000Command;
276
+
+
277
+
+typedef struct {
278
+
+ const Cb2000Command *commands;
279
+
+ const char *seq_name;
280
+
+ gint cmd_index;
281
+
+ gint cmd_total;
282
+
+} Cb2000CmdContext;
283
+
+
284
+
+typedef enum {
285
+
+ CB2000_RETRY_BACKGROUND_CAPTURE = 0,
286
+
+ CB2000_RETRY_AREA_GATE,
287
+
+ CB2000_RETRY_QUALITY_GATE,
288
+
+ CB2000_RETRY_MINUTIAE_PRECHECK,
289
+
+ CB2000_RETRY_DEVICE_STATUS,
290
+
+ CB2000_RETRY_CAUSE_COUNT,
291
+
+} Cb2000RetryCause;
292
+
+
293
+
+typedef enum {
294
+
+ CB2000_VERIFY_ACK_UNKNOWN = 0,
295
+
+ CB2000_VERIFY_ACK_READY,
296
+
+ CB2000_VERIFY_ACK_RETRY,
297
+
+ CB2000_VERIFY_ACK_DEVICE_NOMATCH,
298
+
+} Cb2000VerifyAckDecision;
299
+
+
300
+
+typedef enum {
301
+
+ CB2000_VERIFY_ROUTE_UNKNOWN = 0,
302
+
+ CB2000_VERIFY_ROUTE_HOST_NBIS,
303
+
+ CB2000_VERIFY_ROUTE_DEVICE_STATUS,
304
+
+ CB2000_VERIFY_ROUTE_DEVICE_NOMATCH,
305
+
+ CB2000_VERIFY_ROUTE_RETRY_GATE,
306
+
+} Cb2000VerifyRoute;
307
+
+
308
+
+typedef enum {
309
+
+ CB2000_VERIFY_RESULT_CLASS_UNKNOWN = 0,
310
+
+ CB2000_VERIFY_RESULT_CLASS_READY,
311
+
+ CB2000_VERIFY_RESULT_CLASS_RETRY,
312
+
+ CB2000_VERIFY_RESULT_CLASS_DEVICE_NOMATCH,
313
+
+ CB2000_VERIFY_RESULT_CLASS_COUNT,
314
+
+} Cb2000VerifyResultClass;
315
+
+
316
+
+typedef enum {
317
+
+ CB2000_VERIFY_READY_MATRIX_UNKNOWN = 0,
318
+
+ CB2000_VERIFY_READY_MATRIX_READY,
319
+
+ CB2000_VERIFY_READY_MATRIX_RETRY,
320
+
+ CB2000_VERIFY_READY_MATRIX_DEVICE_NOMATCH,
321
+
+} Cb2000VerifyReadyMatrixDecision;
322
+
+
323
+
+/* ============================================================================
324
+
+ * DEVICE STRUCTURE
325
+
+ * ============================================================================ */
326
+
+struct _FpiDeviceCanvasbioCb2000 {
327
+
+ FpDevice parent;
328
+
+
329
+
+ /* Lifecycle */
330
+
+ gboolean deactivating;
331
+
+ gboolean deactivation_in_progress;
332
+
+
333
+
+ /* NCC enrollment state */
334
+
+ guint8 *enroll_images[5];
335
+
+ gint enroll_stage;
336
+
+ FpiMatchResult verify_result;
337
+
+
338
+
+ /* Image buffer */
339
+
+ guint8 *image_buffer;
340
+
+ guint8 *background_buffer;
341
+
+ guint8 *previous_norm_buffer;
342
+
+ gboolean background_valid;
343
+
+ gboolean previous_norm_valid;
344
+
+ gsize image_offset;
345
+
+ gint chunks_read;
346
+
+
347
+
+ /* Polling counters (reset each sub-SSM) */
348
+
+ gint poll_stable_hits;
349
+
+ gint no_finger_streak;
350
+
+ gint removal_poll_count;
351
+
+ gint removal_stable_off_hits;
352
+
+ gint poll_total_count;
353
+
+ gboolean early_placement_detected;
354
+
+ gint64 poll_start_us;
355
+
+ gint64 removal_start_us;
356
+
+
357
+
+ /* SSM tracking */
358
+
+ FpiSsm *cycle_ssm; /* Master cycle SSM (single reference) */
359
+
+ guint settle_timeout_id; /* Only external timer */
360
+
+ guint poll_timeout_id;
361
+
+ guint removal_timeout_id;
362
+
+ guint early_timeout_id;
363
+
+ guint deactivation_timeout_id;
364
+
+ gboolean force_recovery;
365
+
+ gboolean initial_activation_done;
366
+
+
367
+
+ /* Runtime diagnostics for retry behavior by cause. */
368
+
+ guint retry_total;
369
+
+ guint accepted_total;
370
+
+ guint retry_cause_count[CB2000_RETRY_CAUSE_COUNT];
371
+
+
372
+
+ /* Runtime telemetry by phase/action. */
373
+
+ guint submit_capture_total;
374
+
+ guint submit_enroll_total;
375
+
+ guint submit_verify_total;
376
+
+ guint submit_identify_total;
377
+
+
378
+
+ /* Verify template telemetry (host-side NBIS path). */
379
+
+ guint verify_template_samples;
380
+
+ guint verify_template_subprints_last;
381
+
+ guint verify_template_subprints_min;
382
+
+ guint verify_template_subprints_max;
383
+
+
384
+
+ /* Trilha B skeleton: runtime flag for device-assisted verify experiments. */
385
+
+ gboolean experimental_device_assisted_verify;
386
+
+
387
+
+ /* Trilha B etapa B2: telemetry for short status reads during verify. */
388
+
+ guint verify_cmd_rx_total;
389
+
+ guint verify_cmd_rx_with_data;
390
+
+ gsize verify_cmd_rx_last_len;
391
+
+ guint8 verify_cmd_rx_last[8];
392
+
+
393
+
+ /* Last capture_finalize ACKs used as verify routing gate. */
394
+
+ gsize finalize_ack1_len;
395
+
+ gsize finalize_ack2_len;
396
+
+ guint8 finalize_ack1[4];
397
+
+ guint8 finalize_ack2[4];
398
+
+ guint8 verify_ack_status_last;
399
+
+ Cb2000VerifyAckDecision verify_ack_decision_last;
400
+
+ guint verify_ack_ready_total;
401
+
+ guint verify_ack_retry_total;
402
+
+ guint verify_ack_nomatch_total;
403
+
+ guint verify_ack_unknown_total;
404
+
+ guint verify_ack_mismatch_total;
405
+
+ guint8 verify_status_code_last;
406
+
+ guint8 verify_result_code_last;
407
+
+ Cb2000VerifyRoute verify_route_last;
408
+
+ Cb2000VerifyResultClass verify_result_class_last;
409
+
+ guint verify_result_class_count[CB2000_VERIFY_RESULT_CLASS_COUNT];
410
+
+ gboolean verify_device_status_short_circuit;
411
+
+ gboolean verify_ready_query_enabled;
412
+
+ gboolean verify_ready_query_b_enabled;
413
+
+
414
+
+ /* READY-query telemetry:
415
+
+ * A = first complementary status query
416
+
+ * B = second complementary status query (V29 matrix decision)
417
+
+ */
418
+
+ guint verify_ready_query_total;
419
+
+ guint8 verify_ready_query_status_last;
420
+
+ gsize verify_ready_query_len;
421
+
+ guint8 verify_ready_query_data[4];
422
+
+ guint verify_ready_query_b_total;
423
+
+ guint8 verify_ready_query_b_status_last;
424
+
+ gsize verify_ready_query_b_len;
425
+
+ guint8 verify_ready_query_b_data[4];
426
+
+ guint verify_ready_query_ready_total;
427
+
+ guint verify_ready_query_retry_total;
428
+
+ guint verify_ready_query_nomatch_total;
429
+
+ guint verify_ready_query_unknown_total;
430
+
+ Cb2000VerifyReadyMatrixDecision verify_ready_matrix_last;
431
+
+ guint verify_ready_matrix_ready_total;
432
+
+ guint verify_ready_matrix_retry_total;
433
+
+ guint verify_ready_matrix_nomatch_total;
434
+
+ guint verify_ready_matrix_unknown_total;
435
+
+
436
+
+ /* Verify pre-capture status probe (Windows: ff:00:01:02 after a8:20). */
437
+
+ guint verify_pre_capture_status_total;
438
+
+ gsize verify_pre_capture_status_len;
439
+
+ guint8 verify_pre_capture_status[4];
440
+
+
441
+
+ /* Deferred verify retry report (consumed in cycle_complete). */
442
+
+ gboolean verify_retry_pending;
443
+
+ FpDeviceRetry verify_retry_error;
444
+
+ guint8 verify_retry_status_code;
445
+
+ guint8 verify_retry_result_code;
446
+
+ gchar verify_retry_message[128];
447
+
+
448
+
+ /* Deferred capture retry report (consumed in cycle_complete). */
449
+
+ gboolean capture_retry_pending;
450
+
+ FpDeviceRetry capture_retry_error;
451
+
+ gchar capture_retry_message[128];
452
+
+};
453
+
+
454
+
+G_DECLARE_FINAL_TYPE(FpiDeviceCanvasbioCb2000, fpi_device_canvasbio_cb2000, FPI, DEVICE_CANVASBIO_CB2000, FpDevice)
455
+
+G_DEFINE_TYPE(FpiDeviceCanvasbioCb2000, fpi_device_canvasbio_cb2000, FP_TYPE_DEVICE)
456
+
+
457
+
+/* ============================================================================
458
+
+ * COMMAND DATA BUFFERS
459
+
+ * ============================================================================ */
460
+
+
461
+
+/* Wake/init commands */
462
+
+static const guint8 data_wake[] = {0x4f, 0x80};
463
+
+static const guint8 data_wake_ack[] = {0xa9, 0x4f, 0x80};
464
+
+static const guint8 data_config_read[] = {0xa8, 0xb9, 0x00};
465
+
+static const guint8 data_trigger[] = {0xa9, 0x09, 0x00, 0x00};
466
+
+static const guint8 data_read_start[] = {0xa9, 0x0c, 0x00};
467
+
+static const guint8 data_read_state[] = {0xa8, 0x20, 0x00, 0x00};
468
+
+static const guint8 data_stop[] = {0xa9, 0x04, 0x00};
469
+
+
470
+
+/* Register configuration commands (15 registers) */
471
+
+static const guint8 data_reg_50[] = {0xa9, 0x50, 0x12, 0x00};
472
+
+static const guint8 data_reg_5f[] = {0xa9, 0x5f, 0x00, 0x00};
473
+
+static const guint8 data_reg_4e[] = {0xa9, 0x4e, 0x02, 0x00};
474
+
+static const guint8 data_reg_60[] = {0xa9, 0x60, 0x21, 0x00};
475
+
+static const guint8 data_reg_61[] = {0xa9, 0x61, 0x70, 0x00};
476
+
+static const guint8 data_reg_62[] = {0xa9, 0x62, 0x00, 0x21};
477
+
+static const guint8 data_reg_63[] = {0xa9, 0x63, 0x00, 0x21};
478
+
+static const guint8 data_reg_64[] = {0xa9, 0x64, 0x04, 0x08};
479
+
+static const guint8 data_reg_65[] = {0xa9, 0x65, 0x85, 0x08};
480
+
+static const guint8 data_reg_66[] = {0xa9, 0x66, 0x0d, 0x00};
481
+
+static const guint8 data_reg_67[] = {0xa9, 0x67, 0x10, 0x00};
482
+
+static const guint8 data_reg_68[] = {0xa9, 0x68, 0x00, 0x0c};
483
+
+static const guint8 data_reg_6b[] = {0xa9, 0x6b, 0x11, 0x70};
484
+
+static const guint8 data_reg_6c[] = {0xa9, 0x6c, 0x00, 0x0e};
485
+
+
486
+
+/* Capture configuration commands */
487
+
+static const guint8 data_cap_03[] = {0xa9, 0x03, 0x00};
488
+
+static const guint8 data_cap_38[] = {0xa9, 0x38, 0x01, 0x00};
489
+
+static const guint8 data_cap_10[] = {0xa9, 0x10, 0x60, 0x00};
490
+
+static const guint8 data_cap_3b[] = {0xa9, 0x3b, 0x14, 0x00};
491
+
+static const guint8 data_cap_3d[] = {0xa9, 0x3d, 0xff, 0x0f};
492
+
+static const guint8 data_cap_26[] = {0xa9, 0x26, 0x30, 0x00};
493
+
+static const guint8 data_cap_2f[] = {0xa9, 0x2f, 0xf6, 0xff};
494
+
+
495
+
+/* Capture start sequence commands */
496
+
+static const guint8 data_cap_read_08[] = {0xa8, 0x08, 0x00};
497
+
+static const guint8 data_cap_09[] = {0xa9, 0x09, 0x00, 0x00};
498
+
+static const guint8 data_cap_3e[] = {0xa8, 0x3e, 0x00, 0x00};
499
+
+static const guint8 data_cap_03_4b[] = {0xa9, 0x03, 0x00, 0x00};
500
+
+static const guint8 data_cap_20[] = {0xa8, 0x20, 0x00, 0x00};
501
+
+static const guint8 data_cap_0d[] = {0xa9, 0x0d, 0x00};
502
+
+static const guint8 data_cap_10_alt[] = {0xa9, 0x10, 0x00, 0x01};
503
+
+static const guint8 data_cap_26_4b[] = {0xa9, 0x26, 0x00, 0x00};
504
+
+static const guint8 data_cap_0c[] = {0xa9, 0x0c, 0x00};
505
+
+static const guint8 data_cap_04_4b[] = {0xa9, 0x04, 0x00, 0x00};
506
+
+static const guint8 data_cap_259[259] = {0xa8, 0x06};
507
+
+
508
+
+/* Detection mode calibration values */
509
+
+static const guint8 data_cap_5d_detect[] = {0xa9, 0x5d, 0x3d, 0x00};
510
+
+static const guint8 data_cap_51_detect[] = {0xa9, 0x51, 0xa8, 0x01};
511
+
+static const guint8 data_cap_51_detect_alt[] = {0xa9, 0x51, 0x68, 0x01};
512
+
+/* Capture mode calibration values (post-detection) */
513
+
+static const guint8 data_cap_5d_capture[] = {0xa9, 0x5d, 0x4d, 0x00};
514
+
+static const guint8 data_cap_51_capture[] = {0xa9, 0x51, 0x88, 0x01};
515
+
+/* Chunk padding (256 zeros) */
516
+
+static const guint8 data_padding[256] = {0};
517
+
+
518
+
+/*
519
+
+ * Verify READY complementary status query.
520
+
+ * This mirrors the RE "status execute/query then commit class" split:
521
+
+ * we ask one extra status sample after finalize before host matcher fallback.
522
+
+ */
523
+
+static const Cb2000Command verify_ready_query_a_cmds[] = {
524
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
525
+
+ {CMD_END, 0, 0, 0, NULL, 0}
526
+
+};
527
+
+
528
+
+static const Cb2000Command verify_ready_query_b_cmds[] = {
529
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
530
+
+ {CMD_END, 0, 0, 0, NULL, 0}
531
+
+};
532
+
+
533
+
+/* ============================================================================
534
+
+ * COMMAND TABLES
535
+
+ * ============================================================================ */
536
+
+
537
+
+/* Activation Phase 1: Wake sequence (PCAP-aligned) */
538
+
+static const Cb2000Command activation_wake_cmds[] = {
539
+
+ {CMD_CTRL_OUT, REQ_INIT, 0x0001, 1, NULL, 0},
540
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 2, NULL, 0},
541
+
+ {CMD_BULK_OUT, 0, 0, 0, data_wake, 2},
542
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
543
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
544
+
+ {CMD_BULK_OUT, 0, 0, 0, data_wake_ack, 3},
545
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
546
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 3, NULL, 0},
547
+
+ {CMD_BULK_OUT, 0, 0, 0, data_config_read, 3},
548
+
+ /* Windows emits a short 3-byte BULK_IN here before register setup starts. */
549
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 3},
550
+
+ {CMD_END, 0, 0, 0, NULL, 0}
551
+
+};
552
+
+
553
+
+/* Activation Phase 2: Register configuration (PCAP-aligned) */
554
+
+static const Cb2000Command activation_regs_cmds[] = {
555
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
556
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_50, 4},
557
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
558
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
559
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_5f, 4},
560
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
561
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
562
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_4e, 4},
563
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
564
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
565
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_60, 4},
566
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
567
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
568
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_61, 4},
569
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
570
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
571
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_62, 4},
572
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
573
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
574
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_63, 4},
575
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
576
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
577
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_64, 4},
578
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
579
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
580
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_65, 4},
581
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
582
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
583
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_66, 4},
584
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
585
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
586
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_67, 4},
587
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
588
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
589
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_68, 4},
590
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
591
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
592
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_6b, 4},
593
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
594
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
595
+
+ {CMD_BULK_OUT, 0, 0, 0, data_reg_6c, 4},
596
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
597
+
+ /* Keep trigger preamble in the next phase to avoid duplicating 0x0002:4. */
598
+
+ {CMD_END, 0, 0, 0, NULL, 0}
599
+
+};
600
+
+
601
+
+/* Activation Phase 3: Init trigger (PCAP-aligned, 7 commands) */
602
+
+static const Cb2000Command activation_trigger_cmds[] = {
603
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
604
+
+ {CMD_BULK_OUT, 0, 0, 0, data_trigger, 4},
605
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
606
+
+ {CMD_CTRL_OUT, REQ_INIT, 0x0001, 1, NULL, 0},
607
+
+ {CMD_CTRL_IN, REQ_POLL, 0x00fe, 0, NULL, 2},
608
+
+ {CMD_CTRL_IN, REQ_POLL, 0x00ff, 0, NULL, 2},
609
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
610
+
+ {CMD_END, 0, 0, 0, NULL, 0}
611
+
+};
612
+
+
613
+
+/* Activation Phase 4: Capture configuration (PCAP-aligned, 27 commands) - detection mode */
614
+
+static const Cb2000Command activation_capture_cmds[] = {
615
+
+ /* activation_trigger already ends with REQ_CONFIG 0x0002 idx=4. */
616
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_5d_detect, 4},
617
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
618
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
619
+
+ {CMD_BULK_OUT, 0, 0, 0,
620
+
+ CB2000_USE_ALT_DETECT_51 ? data_cap_51_detect_alt : data_cap_51_detect, 4},
621
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
622
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
623
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_03, 3},
624
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
625
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
626
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_38, 4},
627
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
628
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
629
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_10, 4},
630
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
631
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
632
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3b, 4},
633
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
634
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
635
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3d, 4},
636
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
637
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
638
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_26, 4},
639
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
640
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
641
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_2f, 4},
642
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
643
+
+ {CMD_END, 0, 0, 0, NULL, 0}
644
+
+};
645
+
+
646
+
+/* Activation Phase 5: Finalize (PCAP-aligned, 11 commands) */
647
+
+static const Cb2000Command activation_finalize_cmds[] = {
648
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
649
+
+ {CMD_BULK_OUT, 0, 0, 0, data_trigger, 4},
650
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
651
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
652
+
+ {CMD_BULK_OUT, 0, 0, 0, data_read_start, 3},
653
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
654
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
655
+
+ {CMD_BULK_OUT, 0, 0, 0, data_read_state, 4},
656
+
+ /* Windows reads 4 bytes from BULK_IN before issuing the stop command. */
657
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4},
658
+
+ {CMD_CTRL_OUT, REQ_INIT, 0x0007, 0, NULL, 0},
659
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
660
+
+ {CMD_BULK_OUT, 0, 0, 0, data_stop, 3},
661
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
662
+
+ {CMD_END, 0, 0, 0, NULL, 0}
663
+
+};
664
+
+
665
+
+/* Soft rearm between captures (PCAP-aligned). */
666
+
+static const Cb2000Command rearm_cmds[] = {
667
+
+ /* Windows verify traces end with REQ_INIT 0x0001 using wIndex=0. */
668
+
+ {CMD_CTRL_OUT, REQ_INIT, 0x0001, 0, NULL, 0},
669
+
+
670
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
671
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_5d_detect, 4},
672
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
673
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
674
+
+ {CMD_BULK_OUT, 0, 0, 0,
675
+
+ CB2000_USE_ALT_DETECT_51 ? data_cap_51_detect_alt : data_cap_51_detect, 4},
676
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
677
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
678
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_03, 3},
679
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
680
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
681
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_38, 4},
682
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
683
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
684
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_10, 4},
685
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
686
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
687
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3b, 4},
688
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
689
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
690
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3d, 4},
691
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
692
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
693
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_26, 4},
694
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
695
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
696
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_2f, 4},
697
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
698
+
+
699
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
700
+
+ {CMD_BULK_OUT, 0, 0, 0, data_trigger, 4},
701
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
702
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
703
+
+ {CMD_BULK_OUT, 0, 0, 0, data_read_start, 3},
704
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
705
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
706
+
+ {CMD_BULK_OUT, 0, 0, 0, data_read_state, 4},
707
+
+ {CMD_CTRL_OUT, REQ_INIT, 0x0007, 0, NULL, 0},
708
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
709
+
+ {CMD_BULK_OUT, 0, 0, 0, data_stop, 3},
710
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
711
+
+ {CMD_END, 0, 0, 0, NULL, 0}
712
+
+};
713
+
+
714
+
+/* Capture start sequence (PCAP-aligned, double capture) - sent after finger detected.
715
+
+ * Phase 2: first capture trigger (a8:08) + quality check (a8:3e).
716
+
+ * Phase 3: post-quality config (a8:20 status reads).
717
+
+ * Phase 4: calibration + second capture trigger (idx=5123). */
718
+
+static const Cb2000Command capture_start_cmds[] = {
719
+
+ /* Phase 2: First capture trigger + quality response */
720
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 3, NULL, 0},
721
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_read_08, 3},
722
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 3}, /* First capture quality: ff:00:XX */
723
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
724
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
725
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
726
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3e, 4},
727
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4}, /* Quality ACK: ff:00:YY:ZZ */
728
+
+ /* Phase 3: Post-quality config */
729
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
730
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_03_4b, 4},
731
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
732
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
733
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_20, 4},
734
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4}, /* Status #2: ff:00:01:07 */
735
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
736
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_0d, 3},
737
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
738
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
739
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_10_alt, 4},
740
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
741
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
742
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_26_4b, 4},
743
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
744
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
745
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
746
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
747
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
748
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_0c, 3},
749
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
750
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
751
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_20, 4},
752
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4}, /* Status #3: ff:00:01:02 */
753
+
+ /* Phase 4: Calibration + second capture trigger */
754
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
755
+
+ /* Switch to CAPTURE mode values (post-detection) */
756
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_5d_capture, 4},
757
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
758
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
759
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_51_capture, 4},
760
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
761
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
762
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_04_4b, 4},
763
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
764
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
765
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
766
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
767
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 5123, NULL, 0},
768
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_259, 259},
769
+
+ {CMD_END, 0, 0, 0, NULL, 0}
770
+
+};
771
+
+
772
+
+/*
773
+
+ * Verify-specific start sequence.
774
+
+ * Kept as a dedicated table (even if currently equal to capture_start_cmds)
775
+
+ * so we can evolve verify 1:1 without impacting enroll/capture flow.
776
+
+ */
777
+
+static const Cb2000Command verify_start_cmds[] = {
778
+
+ /* Phase 2: First capture trigger + quality response */
779
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 3, NULL, 0},
780
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_read_08, 3},
781
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 3}, /* First capture quality: ff:00:XX */
782
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
783
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
784
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
785
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3e, 4},
786
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4}, /* Quality ACK: ff:00:YY:ZZ */
787
+
+ /* Phase 3: Post-quality config */
788
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
789
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_03_4b, 4},
790
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
791
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
792
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_20, 4},
793
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4}, /* Status #2: ff:00:01:07 */
794
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
795
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_0d, 3},
796
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
797
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
798
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_10_alt, 4},
799
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
800
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
801
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_26_4b, 4},
802
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
803
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
804
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
805
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
806
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
807
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_0c, 3},
808
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
809
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
810
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_20, 4},
811
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4}, /* Status #3: ff:00:01:02 */
812
+
+ /* Phase 4: Calibration + second capture trigger */
813
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
814
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_5d_capture, 4},
815
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
816
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
817
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_51_capture, 4},
818
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
819
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
820
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_04_4b, 4},
821
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
822
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
823
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
824
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
825
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 5123, NULL, 0},
826
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_259, 259},
827
+
+ {CMD_END, 0, 0, 0, NULL, 0}
828
+
+};
829
+
+
830
+
+/* Capture finalize sequence (PCAP-aligned) */
831
+
+static const Cb2000Command capture_finalize_cmds[] = {
832
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
833
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
834
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
835
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
836
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3e, 4},
837
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4},
838
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
839
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3e, 4},
840
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4},
841
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
842
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_0d, 3},
843
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
844
+
+ {CMD_END, 0, 0, 0, NULL, 0}
845
+
+};
846
+
+
847
+
+/*
848
+
+ * Verify-specific finalize sequence.
849
+
+ * Dedicated table to isolate verify evolution from enroll/capture behavior.
850
+
+ */
851
+
+static const Cb2000Command verify_finalize_cmds[] = {
852
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 4, NULL, 0},
853
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_09, 4},
854
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
855
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
856
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3e, 4},
857
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4},
858
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0003, 4, NULL, 0},
859
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_3e, 4},
860
+
+ {CMD_BULK_IN, 0, 0, 0, NULL, 4},
861
+
+ {CMD_CTRL_OUT, REQ_CONFIG, 0x0002, 3, NULL, 0},
862
+
+ {CMD_BULK_OUT, 0, 0, 0, data_cap_0d, 3},
863
+
+ {CMD_CTRL_IN, REQ_STATUS, 0x0000, 0, NULL, 4},
864
+
+ {CMD_END, 0, 0, 0, NULL, 0}
865
+
+};
866
+
+
867
+
+/* ============================================================================
868
+
+ * SEQUENTIAL COMMAND EXECUTOR
869
+
+ * ============================================================================ */
870
+
+
871
+
+/* Forward declarations */
872
+
+static void cmd_sequence_run(FpiSsm *ssm, FpDevice *dev);
873
+
+static void cmd_transfer_cb(FpiUsbTransfer *transfer, FpDevice *dev,
874
+
+ gpointer user_data, GError *error);
875
+
+static const char *cb2000_cmd_type_to_str(Cb2000CmdType type);
876
+
+static gboolean cb2000_is_verify_phase_action(FpiDeviceAction action);
877
+
+static const char *cb2000_capture_start_seq_name_for_action(FpiDeviceAction action);
878
+
+static const char *cb2000_capture_finalize_seq_name_for_action(FpiDeviceAction action);
879
+
+static gboolean cb2000_seq_is_capture_finalize(const char *seq_name);
880
+
+static const char *cb2000_verify_ack_decision_label(Cb2000VerifyAckDecision decision);
881
+
+static const char *cb2000_verify_result_class_label(Cb2000VerifyResultClass klass);
882
+
+static Cb2000VerifyResultClass
883
+
+cb2000_classify_verify_result_codes(guint8 status_code, guint8 result_code);
884
+
+static const char *cb2000_verify_ready_query_class_label(guint8 status0);
885
+
+static const char *cb2000_verify_ready_matrix_label(Cb2000VerifyReadyMatrixDecision decision);
886
+
+static Cb2000VerifyReadyMatrixDecision
887
+
+cb2000_decide_ready_query_matrix(guint8 status_a, gboolean has_b, guint8 status_b);
888
+
+static Cb2000VerifyAckDecision
889
+
+cb2000_classify_finalize_ack(FpiDeviceCanvasbioCb2000 *self, guint8 *status_hint, gboolean *mismatch_out);
890
+
+static void cb2000_log_cmd_rx_data(FpDevice *dev,
891
+
+ const Cb2000CmdContext *ctx,
892
+
+ const Cb2000Command *cmd,
893
+
+ const FpiUsbTransfer *transfer);
894
+
+static gboolean cb2000_verify_finalize_ack_gate(FpDevice *dev,
895
+
+ FpiDeviceCanvasbioCb2000 *self);
896
+
+static void complete_deactivation(FpDevice *dev);
897
+
+static gboolean deactivation_force_cb(gpointer user_data);
898
+
+static void start_new_cycle(FpDevice *dev);
899
+
+
900
+
+/* Invert grayscale image in-place (sensor outputs inverted polarity). */
901
+
+static void G_GNUC_UNUSED
902
+
+invert_image_u8(guint8 *data, gsize len)
903
+
+{
904
+
+ for (gsize i = 0; i < len; i++)
905
+
+ data[i] = 0xff - data[i];
906
+
+}
907
+
+
908
+
+static gboolean
909
+
+cb2000_dump_binarized_enabled(void)
910
+
+{
911
+
+ const gchar *v = g_getenv("CB2000_DUMP_BIN");
912
+
+ if (!v)
913
+
+ return FALSE;
914
+
+ return g_ascii_strcasecmp(v, "1") == 0 ||
915
+
+ g_ascii_strcasecmp(v, "true") == 0 ||
916
+
+ g_ascii_strcasecmp(v, "yes") == 0;
917
+
+}
918
+
+
919
+
+/*
920
+
+ * Parse a boolean env var with explicit defaults.
921
+
+ * Accepted true values: 1,true,yes,on
922
+
+ * Accepted false values: 0,false,no,off
923
+
+ */
924
+
+static gboolean
925
+
+cb2000_get_env_bool(const gchar *name, gboolean default_value)
926
+
+{
927
+
+ const gchar *v = g_getenv(name);
928
+
+ if (!v || !*v)
929
+
+ return default_value;
930
+
+
931
+
+ if (g_ascii_strcasecmp(v, "1") == 0 ||
932
+
+ g_ascii_strcasecmp(v, "true") == 0 ||
933
+
+ g_ascii_strcasecmp(v, "yes") == 0 ||
934
+
+ g_ascii_strcasecmp(v, "on") == 0)
935
+
+ return TRUE;
936
+
+
937
+
+ if (g_ascii_strcasecmp(v, "0") == 0 ||
938
+
+ g_ascii_strcasecmp(v, "false") == 0 ||
939
+
+ g_ascii_strcasecmp(v, "no") == 0 ||
940
+
+ g_ascii_strcasecmp(v, "off") == 0)
941
+
+ return FALSE;
942
+
+
943
+
+ return default_value;
944
+
+}
945
+
+
946
+
+static int
947
+
+cb2000_parse_upscale_value(const gchar *v, int default_value)
948
+
+{
949
+
+ if (!v || !*v)
950
+
+ return default_value;
951
+
+
952
+
+ int f = atoi(v);
953
+
+ if (f < 1)
954
+
+ f = 1;
955
+
+ if (f > 8)
956
+
+ f = 8;
957
+
+ return f;
958
+
+}
959
+
+
960
+
+static int
961
+
+cb2000_get_env_int(const gchar *name,
962
+
+ int default_value,
963
+
+ int min_value,
964
+
+ int max_value)
965
+
+{
966
+
+ const gchar *v = g_getenv(name);
967
+
+ int out;
968
+
+
969
+
+ out = default_value;
970
+
+ if (v && *v)
971
+
+ out = atoi(v);
972
+
+
973
+
+ if (out < min_value)
974
+
+ out = min_value;
975
+
+ if (out > max_value)
976
+
+ out = max_value;
977
+
+
978
+
+ return out;
979
+
+}
980
+
+
981
+
+static const gchar *
982
+
+cb2000_retry_cause_label(Cb2000RetryCause cause)
983
+
+{
984
+
+ switch (cause) {
985
+
+ case CB2000_RETRY_BACKGROUND_CAPTURE:
986
+
+ return "background_capture";
987
+
+ case CB2000_RETRY_AREA_GATE:
988
+
+ return "area_gate";
989
+
+ case CB2000_RETRY_QUALITY_GATE:
990
+
+ return "quality_gate";
991
+
+ case CB2000_RETRY_MINUTIAE_PRECHECK:
992
+
+ return "minutiae_precheck";
993
+
+ case CB2000_RETRY_DEVICE_STATUS:
994
+
+ return "device_status";
995
+
+ case CB2000_RETRY_CAUSE_COUNT:
996
+
+ return "count_sentinel";
997
+
+ default:
998
+
+ return "unknown";
999
+
+ }
1000
+
+}
1001
+
+
1002
+
+/*
1003
+
+ * Retry-class status pairs observed in Windows captures.
1004
+
+ * We keep this conservative: unknown values never become hard decisions.
1005
+
+ */
1006
+
+static gboolean
1007
+
+cb2000_is_verify_retry_status_pair(guint8 status_code, guint8 result_code)
1008
+
+{
1009
+
+ if (status_code == 0x00 && result_code == 0x00)
1010
+
+ return TRUE;
1011
+
+ if (status_code == 0x0f && result_code == 0x00)
1012
+
+ return TRUE;
1013
+
+ if (status_code == 0xff && result_code == 0x0c)
1014
+
+ return TRUE;
1015
+
+
1016
+
+ /* New retry-class ACKs seen in 2026-02-16 Windows verify error captures. */
1017
+
+ if (status_code == 0xf0 && result_code == 0x0f)
1018
+
+ return TRUE;
1019
+
+ if (status_code == 0xf3 && result_code == 0x0f)
1020
+
+ return TRUE;
1021
+
+ if (status_code == 0x88 && result_code == 0x08)
1022
+
+ return TRUE;
1023
+
+ if (status_code == 0x11 && result_code == 0x01)
1024
+
+ return TRUE;
1025
+
+ if (status_code == 0x08 && result_code == 0x00)
1026
+
+ return TRUE;
1027
+
+ if (status_code == 0x20 && result_code == 0x0f)
1028
+
+ return TRUE;
1029
+
+ if (status_code == 0x00 && result_code == 0x08)
1030
+
+ return TRUE;
1031
+
+ if (status_code == 0x11 && result_code == 0x00)
1032
+
+ return TRUE;
1033
+
+ if (status_code == 0x30 && result_code == 0x0f)
1034
+
+ return TRUE;
1035
+
+
1036
+
+ return FALSE;
1037
+
+}
1038
+
+
1039
+
+static FpDeviceRetry
1040
+
+cb2000_retry_error_from_verify_status_pair(guint8 status_code, guint8 result_code)
1041
+
+{
1042
+
+ /*
1043
+
+ * Direction/placement-like hints from Windows Hello feedback:
1044
+
+ * - 20:0f -> move up
1045
+
+ * - 11:00 -> move right
1046
+
+ * - 88:08 -> move left
1047
+
+ */
1048
+
+ if ((status_code == 0x20 && result_code == 0x0f) ||
1049
+
+ (status_code == 0x11 && result_code == 0x00) ||
1050
+
+ (status_code == 0x88 && result_code == 0x08))
1051
+
+ return FP_DEVICE_RETRY_CENTER_FINGER;
1052
+
+
1053
+
+ /* Generic placement instability buckets observed in retry-only cycles. */
1054
+
+ if ((status_code == 0x11 && result_code == 0x01) ||
1055
+
+ (status_code == 0xf0 && result_code == 0x0f) ||
1056
+
+ (status_code == 0xf3 && result_code == 0x0f))
1057
+
+ return FP_DEVICE_RETRY_CENTER_FINGER;
1058
+
+
1059
+
+ /* Lift/replace style hint for unstable edge-contact / contamination states. */
1060
+
+ if ((status_code == 0x08 && result_code == 0x00) ||
1061
+
+ (status_code == 0x00 && result_code == 0x08))
1062
+
+ return FP_DEVICE_RETRY_REMOVE_FINGER;
1063
+
+
1064
+
+ /* "Try a different finger" in Windows; keep as generic retry. */
1065
+
+ if (status_code == 0x30 && result_code == 0x0f)
1066
+
+ return FP_DEVICE_RETRY_GENERAL;
1067
+
+
1068
+
+ return FP_DEVICE_RETRY_GENERAL;
1069
+
+}
1070
+
+
1071
+
+static const gchar *
1072
+
+cb2000_retry_message_from_verify_status_pair(guint8 status_code, guint8 result_code)
1073
+
+{
1074
+
+ if (status_code == 0x20 && result_code == 0x0f)
1075
+
+ return "Move finger slightly up and try again.";
1076
+
+ if (status_code == 0x11 && result_code == 0x00)
1077
+
+ return "Move finger slightly right and try again.";
1078
+
+ if (status_code == 0x88 && result_code == 0x08)
1079
+
+ return "Move finger slightly left and try again.";
1080
+
+ if (status_code == 0x00 && result_code == 0x08)
1081
+
+ return "Clean the sensor and try again.";
1082
+
+ if (status_code == 0x30 && result_code == 0x0f)
1083
+
+ return "Try a different finger.";
1084
+
+ if (status_code == 0x08 && result_code == 0x00)
1085
+
+ return "Lift and place finger again.";
1086
+
+ if ((status_code == 0xf0 && result_code == 0x0f) ||
1087
+
+ (status_code == 0xf3 && result_code == 0x0f) ||
1088
+
+ (status_code == 0x11 && result_code == 0x01))
1089
+
+ return "Adjust finger placement and try again.";
1090
+
+
1091
+
+ return NULL;
1092
+
+}
1093
+
+
1094
+
+static const gchar *
1095
+
+cb2000_retry_error_label(FpDeviceRetry retry_error)
1096
+
+{
1097
+
+ switch (retry_error) {
1098
+
+ case FP_DEVICE_RETRY_GENERAL:
1099
+
+ return "GENERAL";
1100
+
+ case FP_DEVICE_RETRY_TOO_SHORT:
1101
+
+ return "TOO_SHORT";
1102
+
+ case FP_DEVICE_RETRY_CENTER_FINGER:
1103
+
+ return "CENTER_FINGER";
1104
+
+ case FP_DEVICE_RETRY_REMOVE_FINGER:
1105
+
+ return "REMOVE_FINGER";
1106
+
+ case FP_DEVICE_RETRY_TOO_FAST:
1107
+
+ return "TOO_FAST";
1108
+
+ default:
1109
+
+ return "UNKNOWN";
1110
+
+ }
1111
+
+}
1112
+
+
1113
+
+static int
1114
+
+cb2000_get_upscale_factor(FpiDeviceAction action)
1115
+
+{
1116
+
+ const gchar *v_phase = NULL;
1117
+
+ const gchar *v_global = g_getenv("CB2000_UPSCALE");
1118
+
+ int action_default = 1;
1119
+
+
1120
+
+ /*
1121
+
+ * Keep preprocess parity between template generation and matching:
1122
+
+ * enroll/verify/identify default to 2x, capture remains 1x.
1123
+
+ */
1124
+
+ switch (action) {
1125
+
+ case FPI_DEVICE_ACTION_NONE:
1126
+
+ case FPI_DEVICE_ACTION_PROBE:
1127
+
+ case FPI_DEVICE_ACTION_OPEN:
1128
+
+ case FPI_DEVICE_ACTION_CLOSE:
1129
+
+ case FPI_DEVICE_ACTION_LIST:
1130
+
+ case FPI_DEVICE_ACTION_DELETE:
1131
+
+ case FPI_DEVICE_ACTION_CLEAR_STORAGE:
1132
+
+ break;
1133
+
+ case FPI_DEVICE_ACTION_VERIFY:
1134
+
+ action_default = 2;
1135
+
+ v_phase = g_getenv("CB2000_VERIFY_UPSCALE");
1136
+
+ break;
1137
+
+ case FPI_DEVICE_ACTION_IDENTIFY:
1138
+
+ action_default = 2;
1139
+
+ v_phase = g_getenv("CB2000_IDENTIFY_UPSCALE");
1140
+
+ break;
1141
+
+ case FPI_DEVICE_ACTION_ENROLL:
1142
+
+ action_default = 2;
1143
+
+ v_phase = g_getenv("CB2000_ENROLL_UPSCALE");
1144
+
+ break;
1145
+
+ case FPI_DEVICE_ACTION_CAPTURE:
1146
+
+ v_phase = g_getenv("CB2000_CAPTURE_UPSCALE");
1147
+
+ break;
1148
+
+ default:
1149
+
+ break;
1150
+
+ }
1151
+
+
1152
+
+ if (v_phase && *v_phase)
1153
+
+ return cb2000_parse_upscale_value(v_phase, action_default);
1154
+
+
1155
+
+ return cb2000_parse_upscale_value(v_global, action_default);
1156
+
+}
1157
+
+
1158
+
+/*
1159
+
+ * Background subtraction helps remove fixed-pattern noise in enroll/capture.
1160
+
+ * Default is configured per action via env knobs, with verify/identify mapped
1161
+
+ * by CB2000_VERIFY_BG_SUBTRACT and others by CB2000_BG_SUBTRACT.
1162
+
+ */
1163
+
+static gboolean
1164
+
+cb2000_should_apply_bg_subtraction(FpiDeviceAction action)
1165
+
+{
1166
+
+ /* Keep verify/identify aligned with enroll defaults for NBIS matching. */
1167
+
+ if (action == FPI_DEVICE_ACTION_VERIFY)
1168
+
+ return cb2000_get_env_bool("CB2000_VERIFY_BG_SUBTRACT", TRUE);
1169
+
+
1170
+
+ if (action == FPI_DEVICE_ACTION_IDENTIFY) {
1171
+
+ const gchar *v_identify = g_getenv("CB2000_IDENTIFY_BG_SUBTRACT");
1172
+
+ if (v_identify && *v_identify)
1173
+
+ return cb2000_get_env_bool("CB2000_IDENTIFY_BG_SUBTRACT", TRUE);
1174
+
+ return cb2000_get_env_bool("CB2000_VERIFY_BG_SUBTRACT", TRUE);
1175
+
+ }
1176
+
+
1177
+
+ if (action == FPI_DEVICE_ACTION_ENROLL) {
1178
+
+ const gchar *v_enroll = g_getenv("CB2000_ENROLL_BG_SUBTRACT");
1179
+
+ if (v_enroll && *v_enroll)
1180
+
+ return cb2000_get_env_bool("CB2000_ENROLL_BG_SUBTRACT", TRUE);
1181
+
+ return cb2000_get_env_bool("CB2000_BG_SUBTRACT", TRUE);
1182
+
+ }
1183
+
+
1184
+
+ if (action == FPI_DEVICE_ACTION_CAPTURE) {
1185
+
+ const gchar *v_capture = g_getenv("CB2000_CAPTURE_BG_SUBTRACT");
1186
+
+ if (v_capture && *v_capture)
1187
+
+ return cb2000_get_env_bool("CB2000_CAPTURE_BG_SUBTRACT", TRUE);
1188
+
+ }
1189
+
+
1190
+
+ return cb2000_get_env_bool("CB2000_BG_SUBTRACT", TRUE);
1191
+
+}
1192
+
+
1193
+
+static double
1194
+
+cb2000_get_ppmm(void)
1195
+
+{
1196
+
+ const char *v_ppmm = g_getenv("CB2000_PPMM");
1197
+
+ if (v_ppmm && *v_ppmm) {
1198
+
+ double ppmm = g_ascii_strtod(v_ppmm, NULL);
1199
+
+ if (ppmm > 0.0)
1200
+
+ return ppmm;
1201
+
+ }
1202
+
+
1203
+
+ const char *v_dpi = g_getenv("CB2000_DPI");
1204
+
+ if (v_dpi && *v_dpi) {
1205
+
+ double dpi = g_ascii_strtod(v_dpi, NULL);
1206
+
+ if (dpi > 0.0)
1207
+
+ return dpi / 25.4;
1208
+
+ }
1209
+
+
1210
+
+ return CB2000_PPMM_DEFAULT;
1211
+
+}
1212
+
+
1213
+
+static gboolean
1214
+
+cb2000_should_precheck_minutiae(FpiDeviceAction action)
1215
+
+{
1216
+
+ const char *v = g_getenv("CB2000_PRECHECK_MINUTIAE");
1217
+
+ if (v && *v && strcmp(v, "0") != 0)
1218
+
+ return TRUE;
1219
+
+
1220
+
+ if (action == FPI_DEVICE_ACTION_VERIFY)
1221
+
+ return cb2000_get_env_bool("CB2000_PRECHECK_VERIFY", FALSE);
1222
+
+
1223
+
+ if (action == FPI_DEVICE_ACTION_IDENTIFY)
1224
+
+ return cb2000_get_env_bool("CB2000_PRECHECK_IDENTIFY", FALSE);
1225
+
+
1226
+
+ if (action == FPI_DEVICE_ACTION_ENROLL)
1227
+
+ return cb2000_get_env_bool("CB2000_PRECHECK_ENROLL", FALSE);
1228
+
+
1229
+
+ if (action == FPI_DEVICE_ACTION_CAPTURE)
1230
+
+ return cb2000_get_env_bool("CB2000_PRECHECK_CAPTURE", FALSE);
1231
+
+
1232
+
+ return FALSE;
1233
+
+}
1234
+
+
1235
+
+static const gchar *
1236
+
+cb2000_action_label(FpiDeviceAction action)
1237
+
+{
1238
+
+ switch (action) {
1239
+
+ case FPI_DEVICE_ACTION_NONE:
1240
+
+ return "none";
1241
+
+ case FPI_DEVICE_ACTION_PROBE:
1242
+
+ return "probe";
1243
+
+ case FPI_DEVICE_ACTION_OPEN:
1244
+
+ return "open";
1245
+
+ case FPI_DEVICE_ACTION_CLOSE:
1246
+
+ return "close";
1247
+
+ case FPI_DEVICE_ACTION_CAPTURE:
1248
+
+ return "capture";
1249
+
+ case FPI_DEVICE_ACTION_LIST:
1250
+
+ return "list";
1251
+
+ case FPI_DEVICE_ACTION_DELETE:
1252
+
+ return "delete";
1253
+
+ case FPI_DEVICE_ACTION_CLEAR_STORAGE:
1254
+
+ return "clear_storage";
1255
+
+ case FPI_DEVICE_ACTION_ENROLL:
1256
+
+ return "enroll";
1257
+
+ case FPI_DEVICE_ACTION_VERIFY:
1258
+
+ return "verify";
1259
+
+ case FPI_DEVICE_ACTION_IDENTIFY:
1260
+
+ return "identify";
1261
+
+ }
1262
+
+
1263
+
+ return "capture";
1264
+
+}
1265
+
+
1266
+
+/*
1267
+
+ * Persist last frame per action for fast offline inspection even when the
1268
+
+ * higher-level example does not emit a PGM (e.g. verify ending in retry).
1269
+
+ * Files are written to $HOME by default.
1270
+
+ */
1271
+
+static gboolean
1272
+
+cb2000_should_save_debug_pgm(FpiDeviceAction action)
1273
+
+{
1274
+
+ gboolean global_default = cb2000_get_env_bool("CB2000_DEBUG_SAVE_PGM", TRUE);
1275
+
+
1276
+
+ switch (action) {
1277
+
+ case FPI_DEVICE_ACTION_NONE:
1278
+
+ case FPI_DEVICE_ACTION_PROBE:
1279
+
+ case FPI_DEVICE_ACTION_OPEN:
1280
+
+ case FPI_DEVICE_ACTION_CLOSE:
1281
+
+ case FPI_DEVICE_ACTION_LIST:
1282
+
+ case FPI_DEVICE_ACTION_DELETE:
1283
+
+ case FPI_DEVICE_ACTION_CLEAR_STORAGE:
1284
+
+ return global_default;
1285
+
+ case FPI_DEVICE_ACTION_VERIFY:
1286
+
+ return cb2000_get_env_bool("CB2000_DEBUG_SAVE_VERIFY", global_default);
1287
+
+ case FPI_DEVICE_ACTION_IDENTIFY:
1288
+
+ return cb2000_get_env_bool("CB2000_DEBUG_SAVE_IDENTIFY", global_default);
1289
+
+ case FPI_DEVICE_ACTION_ENROLL:
1290
+
+ return cb2000_get_env_bool("CB2000_DEBUG_SAVE_ENROLL", global_default);
1291
+
+ case FPI_DEVICE_ACTION_CAPTURE:
1292
+
+ return cb2000_get_env_bool("CB2000_DEBUG_SAVE_CAPTURE", global_default);
1293
+
+ default:
1294
+
+ return global_default;
1295
+
+ }
1296
+
+}
1297
+
+
1298
+
+static const gchar *
1299
+
+cb2000_debug_pgm_name(FpiDeviceAction action)
1300
+
+{
1301
+
+ switch (action) {
1302
+
+ case FPI_DEVICE_ACTION_NONE:
1303
+
+ case FPI_DEVICE_ACTION_PROBE:
1304
+
+ case FPI_DEVICE_ACTION_OPEN:
1305
+
+ case FPI_DEVICE_ACTION_CLOSE:
1306
+
+ case FPI_DEVICE_ACTION_LIST:
1307
+
+ case FPI_DEVICE_ACTION_DELETE:
1308
+
+ case FPI_DEVICE_ACTION_CLEAR_STORAGE:
1309
+
+ return "canvasbio_debug.pgm";
1310
+
+ case FPI_DEVICE_ACTION_CAPTURE:
1311
+
+ return "finger.pgm";
1312
+
+ case FPI_DEVICE_ACTION_ENROLL:
1313
+
+ return "enrolled.pgm";
1314
+
+ case FPI_DEVICE_ACTION_VERIFY:
1315
+
+ case FPI_DEVICE_ACTION_IDENTIFY:
1316
+
+ return "verify.pgm";
1317
+
+ default:
1318
+
+ return "canvasbio_debug.pgm";
1319
+
+ }
1320
+
+}
1321
+
+
1322
+
+static const gchar *
1323
+
+cb2000_get_output_dir(void)
1324
+
+{
1325
+
+ const gchar *out_dir = g_getenv("CB2000_OUTPUT_DIR");
1326
+
+ const gchar *home;
1327
+
+
1328
+
+ if (out_dir && *out_dir)
1329
+
+ return out_dir;
1330
+
+
1331
+
+ home = g_get_home_dir();
1332
+
+ if (home && *home)
1333
+
+ return home;
1334
+
+
1335
+
+ return ".";
1336
+
+}
1337
+
+
1338
+
+static void
1339
+
+cb2000_save_debug_pgm(FpImage *img, FpiDeviceAction action)
1340
+
+{
1341
+
+ const gchar *out_dir;
1342
+
+ g_autofree gchar *pgm_path = NULL;
1343
+
+ g_autofree gchar *header = NULL;
1344
+
+ g_autofree guint8 *pgm_data = NULL;
1345
+
+ gsize pixels;
1346
+
+ gsize header_len;
1347
+
+ gsize total_len;
1348
+
+ g_autoptr(GError) error = NULL;
1349
+
+
1350
+
+ if (!img || !cb2000_should_save_debug_pgm(action))
1351
+
+ return;
1352
+
+
1353
+
+ out_dir = cb2000_get_output_dir();
1354
+
+ g_mkdir_with_parents(out_dir, 0755);
1355
+
+ pgm_path = g_build_filename(out_dir, cb2000_debug_pgm_name(action), NULL);
1356
+
+
1357
+
+ pixels = (gsize)img->width * (gsize)img->height;
1358
+
+ header = g_strdup_printf("P5\n%d %d\n255\n", img->width, img->height);
1359
+
+ header_len = strlen(header);
1360
+
+ total_len = header_len + pixels;
1361
+
+ pgm_data = g_malloc(total_len);
1362
+
+
1363
+
+ memcpy(pgm_data, header, header_len);
1364
+
+ memcpy(pgm_data + header_len, img->data, pixels);
1365
+
+
1366
+
+ if (!g_file_set_contents(pgm_path, (const gchar *)pgm_data, total_len, &error)) {
1367
+
+ fp_warn("Failed to save debug PGM %s: %s", pgm_path,
1368
+
+ error ? error->message : "unknown");
1369
+
+ return;
1370
+
+ }
1371
+
+
1372
+
+ fp_dbg("Saved debug PGM: %s (%dx%d)", pgm_path, img->width, img->height);
1373
+
+}
1374
+
+
1375
+
+static int
1376
+
+cb2000_get_area_min_pct(FpiDeviceAction action)
1377
+
+{
1378
+
+ int action_default = CB2000_AREA_MIN_CAPTURE_PCT;
1379
+
+ int global_min = cb2000_get_env_int("CB2000_AREA_MIN",
1380
+
+ CB2000_AREA_MIN_CAPTURE_PCT,
1381
+
+ 1, 100);
1382
+
+ int capture_min = 0;
1383
+
+
1384
+
+ /* Non-image actions still need explicit handling to keep -Wswitch-enum clean. */
1385
+
+ capture_min = cb2000_get_env_int("CB2000_AREA_MIN_CAPTURE", global_min, 1, 100);
1386
+
+
1387
+
+ switch (action) {
1388
+
+ case FPI_DEVICE_ACTION_NONE:
1389
+
+ case FPI_DEVICE_ACTION_PROBE:
1390
+
+ case FPI_DEVICE_ACTION_OPEN:
1391
+
+ case FPI_DEVICE_ACTION_CLOSE:
1392
+
+ case FPI_DEVICE_ACTION_LIST:
1393
+
+ case FPI_DEVICE_ACTION_DELETE:
1394
+
+ case FPI_DEVICE_ACTION_CLEAR_STORAGE:
1395
+
+ return capture_min;
1396
+
+ case FPI_DEVICE_ACTION_ENROLL:
1397
+
+ action_default = CB2000_AREA_MIN_ENROLL_PCT;
1398
+
+ global_min = cb2000_get_env_int("CB2000_AREA_MIN",
1399
+
+ action_default, 1, 100);
1400
+
+ return cb2000_get_env_int("CB2000_AREA_MIN_ENROLL", global_min, 1, 100);
1401
+
+ case FPI_DEVICE_ACTION_VERIFY:
1402
+
+ case FPI_DEVICE_ACTION_IDENTIFY:
1403
+
+ action_default = CB2000_AREA_MIN_VERIFY_PCT;
1404
+
+ global_min = cb2000_get_env_int("CB2000_AREA_MIN",
1405
+
+ action_default, 1, 100);
1406
+
+ return cb2000_get_env_int("CB2000_AREA_MIN_VERIFY", global_min, 1, 100);
1407
+
+ case FPI_DEVICE_ACTION_CAPTURE:
1408
+
+ default:
1409
+
+ return capture_min;
1410
+
+ }
1411
+
+}
1412
+
+
1413
+
+/* Internal helper: read internal NBIS subprint cardinality for telemetry only. */
1414
+
+static guint
1415
+
+cb2000_get_subprint_count(FpPrint *print)
1416
+
+{
1417
+
+ GPtrArray *prints = NULL;
1418
+
+
1419
+
+ if (!print)
1420
+
+ return 0;
1421
+
+
1422
+
+ if (!g_object_class_find_property(G_OBJECT_GET_CLASS(print), "fpi-prints"))
1423
+
+ return 0;
1424
+
+
1425
+
+ g_object_get(print, "fpi-prints", &prints, NULL);
1426
+
+ if (!prints)
1427
+
+ return 0;
1428
+
+
1429
+
+ /*
1430
+
+ * `fpi-prints` is exposed as G_PARAM_POINTER in libfprint (private API).
1431
+
+ * Ownership stays with FpPrint; unref'ing here can free internal storage.
1432
+
+ */
1433
+
+ return prints->len;
1434
+
+}
1435
+
+
1436
+
+static void G_GNUC_UNUSED
1437
+
+cb2000_log_preprocess_profile(FpiDeviceAction action)
1438
+
+{
1439
+
+ fp_info("[ PROFILE ] action=%s bg_subtract=%d upscale=%dx precheck=%d area_min=%d",
1440
+
+ cb2000_action_label(action),
1441
+
+ cb2000_should_apply_bg_subtraction(action),
1442
+
+ cb2000_get_upscale_factor(action),
1443
+
+ cb2000_should_precheck_minutiae(action),
1444
+
+ cb2000_get_area_min_pct(action));
1445
+
+}
1446
+
+
1447
+
+static void
1448
+
+cb2000_update_submit_telemetry(FpiDeviceCanvasbioCb2000 *self,
1449
+
+ FpDevice *dev,
1450
+
+ FpiDeviceAction action)
1451
+
+{
1452
+
+ switch (action) {
1453
+
+ case FPI_DEVICE_ACTION_NONE:
1454
+
+ case FPI_DEVICE_ACTION_PROBE:
1455
+
+ case FPI_DEVICE_ACTION_OPEN:
1456
+
+ case FPI_DEVICE_ACTION_CLOSE:
1457
+
+ case FPI_DEVICE_ACTION_LIST:
1458
+
+ case FPI_DEVICE_ACTION_DELETE:
1459
+
+ case FPI_DEVICE_ACTION_CLEAR_STORAGE:
1460
+
+ break;
1461
+
+ case FPI_DEVICE_ACTION_CAPTURE:
1462
+
+ self->submit_capture_total++;
1463
+
+ break;
1464
+
+ case FPI_DEVICE_ACTION_ENROLL:
1465
+
+ self->submit_enroll_total++;
1466
+
+ break;
1467
+
+ case FPI_DEVICE_ACTION_VERIFY: {
1468
+
+ FpPrint *template = NULL;
1469
+
+ guint subprints = 0;
1470
+
+
1471
+
+ self->submit_verify_total++;
1472
+
+ fpi_device_get_verify_data(dev, &template);
1473
+
+ subprints = cb2000_get_subprint_count(template);
1474
+
+
1475
+
+ self->verify_template_subprints_last = subprints;
1476
+
+ if (self->verify_template_samples == 0) {
1477
+
+ self->verify_template_subprints_min = subprints;
1478
+
+ self->verify_template_subprints_max = subprints;
1479
+
+ } else {
1480
+
+ self->verify_template_subprints_min =
1481
+
+ MIN(self->verify_template_subprints_min, subprints);
1482
+
+ self->verify_template_subprints_max =
1483
+
+ MAX(self->verify_template_subprints_max, subprints);
1484
+
+ }
1485
+
+ self->verify_template_samples++;
1486
+
+
1487
+
+ fp_info("[ VERIFY ] attempt=%u template_subprints=%u (min=%u max=%u samples=%u)",
1488
+
+ self->submit_verify_total,
1489
+
+ subprints,
1490
+
+ self->verify_template_subprints_min,
1491
+
+ self->verify_template_subprints_max,
1492
+
+ self->verify_template_samples);
1493
+
+ break;
1494
+
+ }
1495
+
+ case FPI_DEVICE_ACTION_IDENTIFY:
1496
+
+ self->submit_identify_total++;
1497
+
+ break;
1498
+
+ default:
1499
+
+ break;
1500
+
+ }
1501
+
+}
1502
+
+
1503
+
+/*
1504
+
+ * Trilha B skeleton:
1505
+
+ * runtime gate for future verify path that uses device-assisted matching.
1506
+
+ * Current behavior intentionally falls back to host-side NBIS matching.
1507
+
+ */
1508
+
+static gboolean G_GNUC_UNUSED
1509
+
+cb2000_try_device_assisted_verify(FpiDeviceCanvasbioCb2000 *self,
1510
+
+ FpDevice *dev,
1511
+
+ FpImage *img)
1512
+
+{
1513
+
+ (void) img;
1514
+
+
1515
+
+ if (!self->experimental_device_assisted_verify)
1516
+
+ return FALSE;
1517
+
+
1518
+
+ switch (self->verify_ack_decision_last) {
1519
+
+ case CB2000_VERIFY_ACK_DEVICE_NOMATCH:
1520
+
+ fp_warn("[ EXP ] device-assisted verify: finalize ACK indicates no-match (status=0x%02x)",
1521
+
+ self->verify_ack_status_last);
1522
+
+ fpi_device_verify_report(dev, FPI_MATCH_FAIL, NULL, NULL);
1523
+
+ return TRUE;
1524
+
+ case CB2000_VERIFY_ACK_READY:
1525
+
+ fp_info("[ EXP ] device-assisted verify: ACK ready (status=0x%02x), host NBIS fallback remains active",
1526
+
+ self->verify_ack_status_last);
1527
+
+ return FALSE;
1528
+
+ case CB2000_VERIFY_ACK_RETRY:
1529
+
+ fp_info("[ EXP ] device-assisted verify: ACK retry already handled by gate");
1530
+
+ return FALSE;
1531
+
+ case CB2000_VERIFY_ACK_UNKNOWN:
1532
+
+ default:
1533
+
+ fp_info("[ EXP ] device-assisted verify: ACK unknown (status=0x%02x), using host NBIS fallback",
1534
+
+ self->verify_ack_status_last);
1535
+
+ return FALSE;
1536
+
+ }
1537
+
+
1538
+
+ return FALSE;
1539
+
+}
1540
+
+
1541
+
+static void
1542
+
+cb2000_retry_scan_with_cause(FpDevice *dev,
1543
+
+ Cb2000RetryCause cause,
1544
+
+ const gchar *detail)
1545
+
+{
1546
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
1547
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
1548
+
+ FpDeviceRetry retry_error = FP_DEVICE_RETRY_GENERAL;
1549
+
+ const gchar *retry_msg = NULL;
1550
+
+ guint cause_count = 0;
1551
+
+
1552
+
+ self->retry_total++;
1553
+
+ if (cause >= 0 && cause < CB2000_RETRY_CAUSE_COUNT) {
1554
+
+ self->retry_cause_count[cause]++;
1555
+
+ cause_count = self->retry_cause_count[cause];
1556
+
+ }
1557
+
+
1558
+
+ if (cause == CB2000_RETRY_DEVICE_STATUS) {
1559
+
+ if (detail && g_strstr_len(detail, -1, "verify finalize ack gate")) {
1560
+
+ retry_error = cb2000_retry_error_from_verify_status_pair(
1561
+
+ self->verify_status_code_last,
1562
+
+ self->verify_result_code_last);
1563
+
+ retry_msg = cb2000_retry_message_from_verify_status_pair(
1564
+
+ self->verify_status_code_last,
1565
+
+ self->verify_result_code_last);
1566
+
+ } else if (detail && g_strstr_len(detail, -1, "verify ready matrix retry")) {
1567
+
+ retry_error = FP_DEVICE_RETRY_CENTER_FINGER;
1568
+
+ retry_msg = "Adjust finger placement and try again.";
1569
+
+ }
1570
+
+
1571
+
+ fp_info("[ RETRY ] action=%s cause=%s total=%u cause_count=%u retry_hint=%s status=0x%02x result=0x%02x msg=\"%s\" %s",
1572
+
+ cb2000_action_label(action),
1573
+
+ cb2000_retry_cause_label(cause),
1574
+
+ self->retry_total,
1575
+
+ cause_count,
1576
+
+ cb2000_retry_error_label(retry_error),
1577
+
+ self->verify_status_code_last,
1578
+
+ self->verify_result_code_last,
1579
+
+ retry_msg ? retry_msg : "",
1580
+
+ detail ? detail : "");
1581
+
+ } else {
1582
+
+ if (cause == CB2000_RETRY_AREA_GATE)
1583
+
+ retry_msg = "Place finger fully on sensor and try again.";
1584
+
+ else if (cause == CB2000_RETRY_QUALITY_GATE)
1585
+
+ retry_msg = "Image quality too low, adjust finger and try again.";
1586
+
+ else if (cause == CB2000_RETRY_MINUTIAE_PRECHECK)
1587
+
+ retry_msg = "Adjust finger and try again.";
1588
+
+
1589
+
+ fp_info("[ RETRY ] action=%s cause=%s total=%u cause_count=%u retry_hint=%s msg=\"%s\" %s",
1590
+
+ cb2000_action_label(action),
1591
+
+ cb2000_retry_cause_label(cause),
1592
+
+ self->retry_total,
1593
+
+ cause_count,
1594
+
+ cb2000_retry_error_label(retry_error),
1595
+
+ retry_msg ? retry_msg : "",
1596
+
+ detail ? detail : "");
1597
+
+ }
1598
+
+
1599
+
+ if (cb2000_is_verify_phase_action(action)) {
1600
+
+ self->verify_retry_pending = TRUE;
1601
+
+ self->verify_retry_error = retry_error;
1602
+
+ self->verify_retry_status_code = self->verify_status_code_last;
1603
+
+ self->verify_retry_result_code = self->verify_result_code_last;
1604
+
+ if (retry_msg) {
1605
+
+ g_strlcpy(self->verify_retry_message, retry_msg,
1606
+
+ sizeof(self->verify_retry_message));
1607
+
+ } else {
1608
+
+ self->verify_retry_message[0] = '\0';
1609
+
+ }
1610
+
+ self->verify_result = FPI_MATCH_ERROR;
1611
+
+ return;
1612
+
+ }
1613
+
+
1614
+
+ if (action == FPI_DEVICE_ACTION_CAPTURE) {
1615
+
+ self->capture_retry_pending = TRUE;
1616
+
+ self->capture_retry_error = retry_error;
1617
+
+ if (retry_msg) {
1618
+
+ g_strlcpy(self->capture_retry_message, retry_msg,
1619
+
+ sizeof(self->capture_retry_message));
1620
+
+ } else {
1621
+
+ self->capture_retry_message[0] = '\0';
1622
+
+ }
1623
+
+ return;
1624
+
+ }
1625
+
+
1626
+
+ if (action == FPI_DEVICE_ACTION_ENROLL) {
1627
+
+ GError *err = NULL;
1628
+
+ if (retry_msg) {
1629
+
+ err = fpi_device_retry_new_msg(retry_error, "%s", retry_msg);
1630
+
+ } else {
1631
+
+ err = fpi_device_retry_new(retry_error);
1632
+
+ }
1633
+
+ fpi_device_enroll_progress(dev, self->enroll_stage, NULL, err);
1634
+
+ }
1635
+
+}
1636
+
+
1637
+
+typedef struct {
1638
+
+ FpDevice *dev;
1639
+
+ FpiSsm *ssm;
1640
+
+ FpImage *img;
1641
+
+ FpiDeviceAction action;
1642
+
+} Cb2000MinutiaePrecheckCtx;
1643
+
+
1644
+
+static void
1645
+
+cb2000_minutiae_precheck_cb(GObject *source, GAsyncResult *res, gpointer user_data)
1646
+
+{
1647
+
+ Cb2000MinutiaePrecheckCtx *ctx = user_data;
1648
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(ctx->dev);
1649
+
+ g_autoptr(GError) error = NULL;
1650
+
+
1651
+
+ if (!fp_image_detect_minutiae_finish(FP_IMAGE(source), res, &error)) {
1652
+
+ fp_warn("Image screening failed with error %s",
1653
+
+ error ? error->message : "unknown");
1654
+
+ fp_warn("Reject! Image quality too bad. (minutiae precheck)");
1655
+
+ g_object_unref(ctx->img);
1656
+
+ cb2000_retry_scan_with_cause(ctx->dev,
1657
+
+ CB2000_RETRY_MINUTIAE_PRECHECK,
1658
+
+ "(precheck)");
1659
+
+ fpi_ssm_next_state(ctx->ssm);
1660
+
+ g_free(ctx);
1661
+
+ return;
1662
+
+ }
1663
+
+
1664
+
+ self->accepted_total++;
1665
+
+ if (ctx->action == FPI_DEVICE_ACTION_CAPTURE) {
1666
+
+ /* Capture action must complete explicitly after async precheck. */
1667
+
+ fpi_device_capture_complete(ctx->dev, ctx->img, NULL);
1668
+
+ fpi_ssm_mark_completed(ctx->ssm);
1669
+
+ g_free(ctx);
1670
+
+ return;
1671
+
+ }
1672
+
+
1673
+
+ /* For other actions, precheck is disabled by default in V33. */
1674
+
+ g_object_unref(ctx->img);
1675
+
+ fpi_ssm_next_state(ctx->ssm);
1676
+
+ g_free(ctx);
1677
+
+}
1678
+
+
1679
+
+static void
1680
+
+cb2000_dump_binarized_cb(GObject *source, GAsyncResult *res, gpointer user_data)
1681
+
+{
1682
+
+ FpImage *img = FP_IMAGE(source);
1683
+
+ g_autoptr(GError) error = NULL;
1684
+
+ g_autofree gchar *label = user_data;
1685
+
+
1686
+
+ if (!fp_image_detect_minutiae_finish(img, res, &error)) {
1687
+
+ fp_warn("Binarized dump: minutiae detect failed: %s",
1688
+
+ error ? error->message : "unknown");
1689
+
+ g_object_unref(img);
1690
+
+ return;
1691
+
+ }
1692
+
+
1693
+
+ gsize len = 0;
1694
+
+ const guchar *bin = fp_image_get_binarized(img, &len);
1695
+
+ if (!bin || len != (gsize)(img->width * img->height)) {
1696
+
+ fp_warn("Binarized dump: invalid buffer");
1697
+
+ g_object_unref(img);
1698
+
+ return;
1699
+
+ }
1700
+
+
1701
+
+ g_autofree gchar *dump_dir = g_build_filename(
1702
+
+ g_get_user_special_dir(G_USER_DIRECTORY_DOWNLOAD),
1703
+
+ "canvasbio_bin", NULL);
1704
+
+ g_mkdir_with_parents(dump_dir, 0755);
1705
+
+
1706
+
+ time_t raw = time(NULL);
1707
+
+ struct tm *tm_info = localtime(&raw);
1708
+
+ char timestamp[32];
1709
+
+ strftime(timestamp, sizeof(timestamp), "%Y%m%d_%H%M%S", tm_info);
1710
+
+
1711
+
+ g_autofree gchar *dump_name =
1712
+
+ g_strdup_printf("canvasbio_%s_%s_bin.pgm", label, timestamp);
1713
+
+ g_autofree gchar *dump_path = g_build_filename(dump_dir, dump_name, NULL);
1714
+
+
1715
+
+ g_autofree guint8 *pgm = g_malloc(len);
1716
+
+ for (gsize i = 0; i < len; i++)
1717
+
+ pgm[i] = bin[i] ? 0x00 : 0xff; /* 1=ridge => black, 0=valley => white */
1718
+
+
1719
+
+ g_autofree gchar *header =
1720
+
+ g_strdup_printf("P5\n%u %u\n255\n", img->width, img->height);
1721
+
+ gsize header_len = strlen(header);
1722
+
+ g_autofree gchar *out = g_malloc(header_len + len);
1723
+
+ memcpy(out, header, header_len);
1724
+
+ memcpy(out + header_len, pgm, len);
1725
+
+
1726
+
+ if (g_file_set_contents(dump_path, out, header_len + len, NULL))
1727
+
+ fp_info("BIN DUMP: %zu bytes -> %s", header_len + len, dump_path);
1728
+
+ else
1729
+
+ fp_warn("BIN DUMP: failed to save %s", dump_path);
1730
+
+
1731
+
+ g_object_unref(img);
1732
+
+}
1733
+
+
1734
+
+/*
1735
+
+ * Run a table-driven USB command sequence inside a sub-SSM.
1736
+
+ * The sub-SSM advances one command per callback and completes at CMD_END.
1737
+
+ */
1738
+
+static void
1739
+
+run_command_sequence(FpiSsm *parent_ssm, FpDevice *dev,
1740
+
+ const char *seq_name,
1741
+
+ const Cb2000Command *cmds)
1742
+
+{
1743
+
+ FpiSsm *subsm;
1744
+
+ Cb2000CmdContext *ctx;
1745
+
+ gint total = 0;
1746
+
+
1747
+
+ ctx = g_new0(Cb2000CmdContext, 1);
1748
+
+ ctx->commands = cmds;
1749
+
+ ctx->seq_name = seq_name ? seq_name : "unnamed_seq";
1750
+
+ ctx->cmd_index = 0;
1751
+
+ while (cmds[total].type != CMD_END)
1752
+
+ total++;
1753
+
+ ctx->cmd_total = total;
1754
+
+
1755
+
+ subsm = fpi_ssm_new(dev, cmd_sequence_run, 1);
1756
+
+ fpi_ssm_set_data(subsm, ctx, g_free);
1757
+
+ fpi_ssm_start_subsm(parent_ssm, subsm);
1758
+
+}
1759
+
+
1760
+
+static const char *
1761
+
+cb2000_cmd_type_to_str(Cb2000CmdType type)
1762
+
+{
1763
+
+ switch (type) {
1764
+
+ case CMD_END:
1765
+
+ return "END";
1766
+
+ case CMD_BULK_OUT:
1767
+
+ return "BULK_OUT";
1768
+
+ case CMD_BULK_IN:
1769
+
+ return "BULK_IN";
1770
+
+ case CMD_CTRL_OUT:
1771
+
+ return "CTRL_OUT";
1772
+
+ case CMD_CTRL_IN:
1773
+
+ return "CTRL_IN";
1774
+
+ default:
1775
+
+ return "UNKNOWN";
1776
+
+ }
1777
+
+}
1778
+
+
1779
+
+static gboolean
1780
+
+cb2000_is_verify_phase_action(FpiDeviceAction action)
1781
+
+{
1782
+
+ return action == FPI_DEVICE_ACTION_VERIFY ||
1783
+
+ action == FPI_DEVICE_ACTION_IDENTIFY;
1784
+
+}
1785
+
+
1786
+
+static const char *
1787
+
+cb2000_capture_start_seq_name_for_action(FpiDeviceAction action)
1788
+
+{
1789
+
+ if (cb2000_is_verify_phase_action(action))
1790
+
+ return "verify_start";
1791
+
+ return "capture_start_enroll";
1792
+
+}
1793
+
+
1794
+
+static const char *
1795
+
+cb2000_capture_finalize_seq_name_for_action(FpiDeviceAction action)
1796
+
+{
1797
+
+ if (cb2000_is_verify_phase_action(action))
1798
+
+ return "verify_finalize";
1799
+
+ return "capture_finalize_enroll";
1800
+
+}
1801
+
+
1802
+
+static const Cb2000Command *
1803
+
+cb2000_capture_start_cmds_for_action(FpiDeviceAction action)
1804
+
+{
1805
+
+ if (cb2000_is_verify_phase_action(action))
1806
+
+ return verify_start_cmds;
1807
+
+ return capture_start_cmds;
1808
+
+}
1809
+
+
1810
+
+static const Cb2000Command *
1811
+
+cb2000_capture_finalize_cmds_for_action(FpiDeviceAction action)
1812
+
+{
1813
+
+ if (cb2000_is_verify_phase_action(action))
1814
+
+ return verify_finalize_cmds;
1815
+
+ return capture_finalize_cmds;
1816
+
+}
1817
+
+
1818
+
+static gboolean
1819
+
+cb2000_seq_is_capture_finalize(const char *seq_name)
1820
+
+{
1821
+
+ return seq_name != NULL &&
1822
+
+ (g_str_has_prefix(seq_name, "capture_finalize") ||
1823
+
+ g_str_has_prefix(seq_name, "verify_finalize"));
1824
+
+}
1825
+
+
1826
+
+/*
1827
+
+ * Log short response payloads from command-sequence reads.
1828
+
+ * This is used to correlate verify status bytes with RE/Windows traces.
1829
+
+ */
1830
+
+static void
1831
+
+cb2000_log_cmd_rx_data(FpDevice *dev,
1832
+
+ const Cb2000CmdContext *ctx,
1833
+
+ const Cb2000Command *cmd,
1834
+
+ const FpiUsbTransfer *transfer)
1835
+
+{
1836
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
1837
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
1838
+
+ gchar hex[3 * 8 + 1];
1839
+
+ gsize max_bytes;
1840
+
+ gsize i;
1841
+
+ gsize p = 0;
1842
+
+
1843
+
+ if (cmd->type != CMD_BULK_IN && cmd->type != CMD_CTRL_IN)
1844
+
+ return;
1845
+
+ if (!cb2000_get_env_bool("CB2000_DEBUG_CMD_RX", TRUE))
1846
+
+ return;
1847
+
+
1848
+
+ self->verify_cmd_rx_total++;
1849
+
+ if (transfer->actual_length == 0) {
1850
+
+ fp_dbg("[%s] cmd %d/%d %s rx len=0",
1851
+
+ ctx->seq_name,
1852
+
+ ctx->cmd_index + 1,
1853
+
+ ctx->cmd_total,
1854
+
+ cb2000_cmd_type_to_str(cmd->type));
1855
+
+ return;
1856
+
+ }
1857
+
+
1858
+
+ self->verify_cmd_rx_with_data++;
1859
+
+ self->verify_cmd_rx_last_len = MIN(transfer->actual_length, sizeof(self->verify_cmd_rx_last));
1860
+
+ memcpy(self->verify_cmd_rx_last, transfer->buffer, self->verify_cmd_rx_last_len);
1861
+
+
1862
+
+ max_bytes = MIN(transfer->actual_length, (gsize)8);
1863
+
+ for (i = 0; i < max_bytes; i++) {
1864
+
+ if (i > 0 && p < sizeof(hex))
1865
+
+ hex[p++] = ':';
1866
+
+ if (p + 2 <= sizeof(hex))
1867
+
+ p += g_snprintf(hex + p, sizeof(hex) - p, "%02x", transfer->buffer[i]);
1868
+
+ }
1869
+
+ hex[MIN(p, sizeof(hex) - 1)] = '\0';
1870
+
+
1871
+
+ fp_dbg("[%s] cmd %d/%d %s rx len=%zu data=%s",
1872
+
+ ctx->seq_name,
1873
+
+ ctx->cmd_index + 1,
1874
+
+ ctx->cmd_total,
1875
+
+ cb2000_cmd_type_to_str(cmd->type),
1876
+
+ transfer->actual_length,
1877
+
+ hex);
1878
+
+
1879
+
+ if (cb2000_is_verify_phase_action(action) &&
1880
+
+ cb2000_seq_is_capture_finalize(ctx->seq_name) &&
1881
+
+ (ctx->cmd_index == 5 || ctx->cmd_index == 8)) {
1882
+
+ guint8 *dst = (ctx->cmd_index == 5) ? self->finalize_ack1 : self->finalize_ack2;
1883
+
+ gsize *dst_len = (ctx->cmd_index == 5) ? &self->finalize_ack1_len : &self->finalize_ack2_len;
1884
+
+ gsize copy_len = MIN(transfer->actual_length, (gsize)4);
1885
+
+ memset(dst, 0, 4);
1886
+
+ memcpy(dst, transfer->buffer, copy_len);
1887
+
+ *dst_len = copy_len;
1888
+
+
1889
+
+ fp_info("[ VERIFY_STATUS ] finalize_ack_%u len=%zu data=%s",
1890
+
+ (ctx->cmd_index == 5) ? 1U : 2U,
1891
+
+ transfer->actual_length,
1892
+
+ hex);
1893
+
+ }
1894
+
+
1895
+
+ if (cb2000_is_verify_phase_action(action) &&
1896
+
+ g_str_has_prefix(ctx->seq_name, "verify_ready_query_a") &&
1897
+
+ ctx->cmd_index == 0) {
1898
+
+ gsize copy_len = MIN(transfer->actual_length, (gsize)4);
1899
+
+ memset(self->verify_ready_query_data, 0, sizeof(self->verify_ready_query_data));
1900
+
+ memcpy(self->verify_ready_query_data, transfer->buffer, copy_len);
1901
+
+ self->verify_ready_query_len = copy_len;
1902
+
+ self->verify_ready_query_status_last = (copy_len > 0) ? transfer->buffer[0] : 0x00;
1903
+
+ self->verify_ready_query_total++;
1904
+
+
1905
+
+ fp_info("[ VERIFY_READY_QUERY_A ] len=%zu data=%s class=%s",
1906
+
+ transfer->actual_length,
1907
+
+ hex,
1908
+
+ cb2000_verify_ready_query_class_label(self->verify_ready_query_status_last));
1909
+
+ }
1910
+
+
1911
+
+ if (cb2000_is_verify_phase_action(action) &&
1912
+
+ g_str_has_prefix(ctx->seq_name, "verify_ready_query_b") &&
1913
+
+ ctx->cmd_index == 0) {
1914
+
+ gsize copy_len = MIN(transfer->actual_length, (gsize)4);
1915
+
+ memset(self->verify_ready_query_b_data, 0, sizeof(self->verify_ready_query_b_data));
1916
+
+ memcpy(self->verify_ready_query_b_data, transfer->buffer, copy_len);
1917
+
+ self->verify_ready_query_b_len = copy_len;
1918
+
+ self->verify_ready_query_b_status_last = (copy_len > 0) ? transfer->buffer[0] : 0x00;
1919
+
+ self->verify_ready_query_b_total++;
1920
+
+
1921
+
+ fp_info("[ VERIFY_READY_QUERY_B ] len=%zu data=%s class=%s",
1922
+
+ transfer->actual_length,
1923
+
+ hex,
1924
+
+ cb2000_verify_ready_query_class_label(self->verify_ready_query_b_status_last));
1925
+
+ }
1926
+
+
1927
+
+ if (cb2000_is_verify_phase_action(action) &&
1928
+
+ g_str_has_prefix(ctx->seq_name, "verify_start") &&
1929
+
+ cmd->type == CMD_BULK_IN &&
1930
+
+ transfer->actual_length == 4 &&
1931
+
+ self->verify_pre_capture_status_len == 0) {
1932
+
+ self->verify_pre_capture_status_len = 4;
1933
+
+ memcpy(self->verify_pre_capture_status, transfer->buffer, 4);
1934
+
+ self->verify_pre_capture_status_total++;
1935
+
+ fp_info("[ VERIFY_PRE_CAPTURE ] len=%zu data=%s",
1936
+
+ transfer->actual_length, hex);
1937
+
+ }
1938
+
+}
1939
+
+
1940
+
+static const char *
1941
+
+cb2000_verify_ack_decision_label(Cb2000VerifyAckDecision decision)
1942
+
+{
1943
+
+ switch (decision) {
1944
+
+ case CB2000_VERIFY_ACK_READY:
1945
+
+ return "READY";
1946
+
+ case CB2000_VERIFY_ACK_RETRY:
1947
+
+ return "RETRY";
1948
+
+ case CB2000_VERIFY_ACK_DEVICE_NOMATCH:
1949
+
+ return "DEVICE_NOMATCH";
1950
+
+ case CB2000_VERIFY_ACK_UNKNOWN:
1951
+
+ default:
1952
+
+ return "UNKNOWN";
1953
+
+ }
1954
+
+}
1955
+
+
1956
+
+static const char *
1957
+
+cb2000_verify_route_label(Cb2000VerifyRoute route)
1958
+
+{
1959
+
+ switch (route) {
1960
+
+ case CB2000_VERIFY_ROUTE_HOST_NBIS:
1961
+
+ return "HOST_NCC";
1962
+
+ case CB2000_VERIFY_ROUTE_DEVICE_STATUS:
1963
+
+ return "DEVICE_STATUS";
1964
+
+ case CB2000_VERIFY_ROUTE_DEVICE_NOMATCH:
1965
+
+ return "DEVICE_NOMATCH";
1966
+
+ case CB2000_VERIFY_ROUTE_RETRY_GATE:
1967
+
+ return "RETRY_GATE";
1968
+
+ case CB2000_VERIFY_ROUTE_UNKNOWN:
1969
+
+ default:
1970
+
+ return "UNKNOWN";
1971
+
+ }
1972
+
+}
1973
+
+
1974
+
+static const char *
1975
+
+cb2000_verify_result_class_label(Cb2000VerifyResultClass klass)
1976
+
+{
1977
+
+ switch (klass) {
1978
+
+ case CB2000_VERIFY_RESULT_CLASS_READY:
1979
+
+ return "READY";
1980
+
+ case CB2000_VERIFY_RESULT_CLASS_RETRY:
1981
+
+ return "RETRY";
1982
+
+ case CB2000_VERIFY_RESULT_CLASS_DEVICE_NOMATCH:
1983
+
+ return "DEVICE_NOMATCH";
1984
+
+ case CB2000_VERIFY_RESULT_CLASS_COUNT:
1985
+
+ case CB2000_VERIFY_RESULT_CLASS_UNKNOWN:
1986
+
+ default:
1987
+
+ return "UNKNOWN";
1988
+
+ }
1989
+
+}
1990
+
+
1991
+
+/*
1992
+
+ * Normalize verify status/result byte pairs into a stable class.
1993
+
+ * This class is used for routing telemetry and for optional short-circuit
1994
+
+ * handling when device status is explicit enough to skip host NBIS.
1995
+
+ */
1996
+
+static Cb2000VerifyResultClass
1997
+
+cb2000_classify_verify_result_codes(guint8 status_code, guint8 result_code)
1998
+
+{
1999
+
+ if (status_code == 0xff && result_code == 0x0f)
2000
+
+ return CB2000_VERIFY_RESULT_CLASS_READY;
2001
+
+ if (cb2000_is_verify_retry_status_pair(status_code, result_code))
2002
+
+ return CB2000_VERIFY_RESULT_CLASS_RETRY;
2003
+
+ if (status_code == 0xff && result_code == 0x0b)
2004
+
+ return CB2000_VERIFY_RESULT_CLASS_DEVICE_NOMATCH;
2005
+
+ return CB2000_VERIFY_RESULT_CLASS_UNKNOWN;
2006
+
+}
2007
+
+
2008
+
+static const char *
2009
+
+cb2000_verify_ready_query_class_label(guint8 status0)
2010
+
+{
2011
+
+ switch (status0) {
2012
+
+ case 0x00:
2013
+
+ return "READY";
2014
+
+ case 0x02:
2015
+
+ return "RETRY_02";
2016
+
+ case 0x0b:
2017
+
+ return "NOMATCH_0B";
2018
+
+ default:
2019
+
+ return "UNKNOWN";
2020
+
+ }
2021
+
+}
2022
+
+
2023
+
+static const char *
2024
+
+cb2000_verify_ready_matrix_label(Cb2000VerifyReadyMatrixDecision decision)
2025
+
+{
2026
+
+ switch (decision) {
2027
+
+ case CB2000_VERIFY_READY_MATRIX_READY:
2028
+
+ return "READY_FALLBACK_HOST";
2029
+
+ case CB2000_VERIFY_READY_MATRIX_RETRY:
2030
+
+ return "RETRY";
2031
+
+ case CB2000_VERIFY_READY_MATRIX_DEVICE_NOMATCH:
2032
+
+ return "DEVICE_NOMATCH";
2033
+
+ case CB2000_VERIFY_READY_MATRIX_UNKNOWN:
2034
+
+ default:
2035
+
+ return "UNKNOWN_FALLBACK_HOST";
2036
+
+ }
2037
+
+}
2038
+
+
2039
+
+/*
2040
+
+ * V29 READY matrix decision.
2041
+
+ * Priority is conservative:
2042
+
+ * 1) any 0x02 -> RETRY
2043
+
+ * 2) any 0x0b -> DEVICE_NOMATCH
2044
+
+ * 3) A=0x00 and (B missing or B=0x00) -> READY fallback to host NBIS
2045
+
+ * 4) otherwise -> UNKNOWN fallback to host NBIS
2046
+
+ */
2047
+
+static Cb2000VerifyReadyMatrixDecision
2048
+
+cb2000_decide_ready_query_matrix(guint8 status_a, gboolean has_b, guint8 status_b)
2049
+
+{
2050
+
+ if (status_a == 0x02 || (has_b && status_b == 0x02))
2051
+
+ return CB2000_VERIFY_READY_MATRIX_RETRY;
2052
+
+ if (status_a == 0x0b || (has_b && status_b == 0x0b))
2053
+
+ return CB2000_VERIFY_READY_MATRIX_DEVICE_NOMATCH;
2054
+
+ if (status_a == 0x00 && (!has_b || status_b == 0x00))
2055
+
+ return CB2000_VERIFY_READY_MATRIX_READY;
2056
+
+ return CB2000_VERIFY_READY_MATRIX_UNKNOWN;
2057
+
+}
2058
+
+
2059
+
+/*
2060
+
+ * Map finalize ACKs to a verify routing decision.
2061
+
+ * Runtime evidence so far:
2062
+
+ * ff:00:ff:0f -> capture ready, proceed to host matcher
2063
+
+ * ff:00:00:00 -> retry
2064
+
+ * ff:00:ff:0c -> retry (observed in poor/partial captures)
2065
+
+ * ff:00:f0:0f, ff:00:f3:0f, ff:00:88:08, ff:00:11:01,
2066
+
+ * ff:00:08:00, ff:00:20:0f, ff:00:00:08, ff:00:11:00,
2067
+
+ * ff:00:30:0f -> retry (Windows verify failures, 2026-02-16)
2068
+
+ *
2069
+
+ * Hypothesis from Windows RE:
2070
+
+ * ff:00:ff:0b -> explicit device no-match status
2071
+
+ */
2072
+
+static Cb2000VerifyAckDecision
2073
+
+cb2000_classify_finalize_ack(FpiDeviceCanvasbioCb2000 *self,
2074
+
+ guint8 *status_hint,
2075
+
+ gboolean *mismatch_out)
2076
+
+{
2077
+
+ gboolean mismatch = FALSE;
2078
+
+ guint8 status = 0x00;
2079
+
+ guint8 result = 0x00;
2080
+
+ Cb2000VerifyResultClass klass;
2081
+
+
2082
+
+ if (self->finalize_ack1_len < 4 || self->finalize_ack2_len < 4)
2083
+
+ return CB2000_VERIFY_ACK_UNKNOWN;
2084
+
+
2085
+
+ mismatch = memcmp(self->finalize_ack1, self->finalize_ack2, 4) != 0;
2086
+
+ if (mismatch) {
2087
+
+ if (mismatch_out)
2088
+
+ *mismatch_out = TRUE;
2089
+
+ return CB2000_VERIFY_ACK_RETRY;
2090
+
+ }
2091
+
+
2092
+
+ status = self->finalize_ack1[2];
2093
+
+ result = self->finalize_ack1[3];
2094
+
+ if (status_hint)
2095
+
+ *status_hint = status;
2096
+
+ if (mismatch_out)
2097
+
+ *mismatch_out = FALSE;
2098
+
+
2099
+
+ if (self->finalize_ack1[0] != 0xff || self->finalize_ack1[1] != 0x00)
2100
+
+ return CB2000_VERIFY_ACK_UNKNOWN;
2101
+
+
2102
+
+ klass = cb2000_classify_verify_result_codes(status, result);
2103
+
+ switch (klass) {
2104
+
+ case CB2000_VERIFY_RESULT_CLASS_READY:
2105
+
+ return CB2000_VERIFY_ACK_READY;
2106
+
+ case CB2000_VERIFY_RESULT_CLASS_RETRY:
2107
+
+ return CB2000_VERIFY_ACK_RETRY;
2108
+
+ case CB2000_VERIFY_RESULT_CLASS_DEVICE_NOMATCH:
2109
+
+ return CB2000_VERIFY_ACK_DEVICE_NOMATCH;
2110
+
+ case CB2000_VERIFY_RESULT_CLASS_COUNT:
2111
+
+ case CB2000_VERIFY_RESULT_CLASS_UNKNOWN:
2112
+
+ default:
2113
+
+ break;
2114
+
+ }
2115
+
+
2116
+
+ return CB2000_VERIFY_ACK_UNKNOWN;
2117
+
+}
2118
+
+
2119
+
+/*
2120
+
+ * Gate verify/identify routing using capture_finalize ACK bytes.
2121
+
+ * This performs only "early exits" (retry). Match/no-match decisions for
2122
+
+ * experimental device-assisted flow are handled later by
2123
+
+ * cb2000_try_device_assisted_verify().
2124
+
+ */
2125
+
+static gboolean
2126
+
+cb2000_verify_finalize_ack_gate(FpDevice *dev,
2127
+
+ FpiDeviceCanvasbioCb2000 *self)
2128
+
+{
2129
+
+ Cb2000VerifyAckDecision decision;
2130
+
+ Cb2000VerifyResultClass result_class = CB2000_VERIFY_RESULT_CLASS_UNKNOWN;
2131
+
+ guint8 status_hint = 0x00;
2132
+
+ gboolean ack_mismatch = FALSE;
2133
+
+
2134
+
+ if (self->finalize_ack1_len < 4 || self->finalize_ack2_len < 4) {
2135
+
+ fp_info("[ VERIFY_GATE ] ack incomplete (ack1_len=%zu ack2_len=%zu) -> allow matcher",
2136
+
+ self->finalize_ack1_len, self->finalize_ack2_len);
2137
+
+ self->verify_ack_decision_last = CB2000_VERIFY_ACK_UNKNOWN;
2138
+
+ self->verify_ack_status_last = 0x00;
2139
+
+ self->verify_status_code_last = 0x00;
2140
+
+ self->verify_result_code_last = 0x00;
2141
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_UNKNOWN;
2142
+
+ self->verify_result_class_last = CB2000_VERIFY_RESULT_CLASS_UNKNOWN;
2143
+
+ self->verify_result_class_count[CB2000_VERIFY_RESULT_CLASS_UNKNOWN]++;
2144
+
+ self->verify_ack_unknown_total++;
2145
+
+ return FALSE;
2146
+
+ }
2147
+
+
2148
+
+ self->verify_status_code_last = self->finalize_ack1[2];
2149
+
+ self->verify_result_code_last = self->finalize_ack1[3];
2150
+
+ result_class = cb2000_classify_verify_result_codes(self->verify_status_code_last,
2151
+
+ self->verify_result_code_last);
2152
+
+ self->verify_result_class_last = result_class;
2153
+
+ self->verify_result_class_count[result_class]++;
2154
+
+
2155
+
+ decision = cb2000_classify_finalize_ack(self, &status_hint, &ack_mismatch);
2156
+
+ self->verify_ack_decision_last = decision;
2157
+
+ self->verify_ack_status_last = status_hint;
2158
+
+
2159
+
+ switch (decision) {
2160
+
+ case CB2000_VERIFY_ACK_READY:
2161
+
+ self->verify_ack_ready_total++;
2162
+
+ break;
2163
+
+ case CB2000_VERIFY_ACK_RETRY:
2164
+
+ self->verify_ack_retry_total++;
2165
+
+ break;
2166
+
+ case CB2000_VERIFY_ACK_DEVICE_NOMATCH:
2167
+
+ self->verify_ack_nomatch_total++;
2168
+
+ break;
2169
+
+ case CB2000_VERIFY_ACK_UNKNOWN:
2170
+
+ default:
2171
+
+ self->verify_ack_unknown_total++;
2172
+
+ break;
2173
+
+ }
2174
+
+
2175
+
+ if (ack_mismatch)
2176
+
+ self->verify_ack_mismatch_total++;
2177
+
+
2178
+
+ fp_info("[ VERIFY_GATE ] ack1=%02x:%02x:%02x:%02x ack2=%02x:%02x:%02x:%02x decision=%s result_class=%s status=0x%02x result=0x%02x mismatch=%d",
2179
+
+ self->finalize_ack1[0], self->finalize_ack1[1],
2180
+
+ self->finalize_ack1[2], self->finalize_ack1[3],
2181
+
+ self->finalize_ack2[0], self->finalize_ack2[1],
2182
+
+ self->finalize_ack2[2], self->finalize_ack2[3],
2183
+
+ cb2000_verify_ack_decision_label(decision),
2184
+
+ cb2000_verify_result_class_label(self->verify_result_class_last),
2185
+
+ status_hint,
2186
+
+ self->verify_result_code_last,
2187
+
+ ack_mismatch);
2188
+
+
2189
+
+ if (decision == CB2000_VERIFY_ACK_RETRY) {
2190
+
+ cb2000_retry_scan_with_cause(dev, CB2000_RETRY_DEVICE_STATUS,
2191
+
+ "(verify finalize ack gate)");
2192
+
+ return TRUE;
2193
+
+ }
2194
+
+
2195
+
+ fp_info("[ VERIFY_GATE ] non-retry decision -> allow matcher/device-assisted flow");
2196
+
+ return FALSE;
2197
+
+}
2198
+
+
2199
+
+/*
2200
+
+ * Execute the next command in the sequence by mapping each entry to a
2201
+
+ * libfprint USB transfer. The callback advances the state machine.
2202
+
+ */
2203
+
+static void
2204
+
+cmd_sequence_run(FpiSsm *ssm, FpDevice *dev)
2205
+
+{
2206
+
+ Cb2000CmdContext *ctx = fpi_ssm_get_data(ssm);
2207
+
+ const Cb2000Command *cmd = &ctx->commands[ctx->cmd_index];
2208
+
+ FpiUsbTransfer *transfer;
2209
+
+
2210
+
+ if (cmd->type == CMD_END) {
2211
+
+ fp_dbg("Command sequence complete (%d commands)", ctx->cmd_total);
2212
+
+ fpi_ssm_mark_completed(ssm);
2213
+
+ return;
2214
+
+ }
2215
+
+
2216
+
+ transfer = fpi_usb_transfer_new(dev);
2217
+
+ transfer->ssm = ssm;
2218
+
+
2219
+
+ switch (cmd->type) {
2220
+
+ case CMD_BULK_OUT:
2221
+
+ if (cmd->data != NULL && cmd->len >= 4) {
2222
+
+ fp_dbg("[%s] cmd %d/%d %s len=%zu data=%02x:%02x:%02x:%02x",
2223
+
+ ctx->seq_name,
2224
+
+ ctx->cmd_index + 1,
2225
+
+ ctx->cmd_total,
2226
+
+ cb2000_cmd_type_to_str(cmd->type),
2227
+
+ cmd->len,
2228
+
+ cmd->data[0], cmd->data[1], cmd->data[2], cmd->data[3]);
2229
+
+ } else if (cmd->data != NULL && cmd->len == 3) {
2230
+
+ fp_dbg("[%s] cmd %d/%d %s len=%zu data=%02x:%02x:%02x",
2231
+
+ ctx->seq_name,
2232
+
+ ctx->cmd_index + 1,
2233
+
+ ctx->cmd_total,
2234
+
+ cb2000_cmd_type_to_str(cmd->type),
2235
+
+ cmd->len,
2236
+
+ cmd->data[0], cmd->data[1], cmd->data[2]);
2237
+
+ } else if (cmd->data != NULL && cmd->len == 2) {
2238
+
+ fp_dbg("[%s] cmd %d/%d %s len=%zu data=%02x:%02x",
2239
+
+ ctx->seq_name,
2240
+
+ ctx->cmd_index + 1,
2241
+
+ ctx->cmd_total,
2242
+
+ cb2000_cmd_type_to_str(cmd->type),
2243
+
+ cmd->len,
2244
+
+ cmd->data[0], cmd->data[1]);
2245
+
+ } else if (cmd->data != NULL && cmd->len == 1) {
2246
+
+ fp_dbg("[%s] cmd %d/%d %s len=%zu data=%02x",
2247
+
+ ctx->seq_name,
2248
+
+ ctx->cmd_index + 1,
2249
+
+ ctx->cmd_total,
2250
+
+ cb2000_cmd_type_to_str(cmd->type),
2251
+
+ cmd->len,
2252
+
+ cmd->data[0]);
2253
+
+ } else {
2254
+
+ fp_dbg("[%s] cmd %d/%d %s len=%zu",
2255
+
+ ctx->seq_name,
2256
+
+ ctx->cmd_index + 1,
2257
+
+ ctx->cmd_total,
2258
+
+ cb2000_cmd_type_to_str(cmd->type),
2259
+
+ cmd->len);
2260
+
+ }
2261
+
+ fpi_usb_transfer_fill_bulk_full(transfer, CB2000_EP_OUT,
2262
+
+ (guint8 *)cmd->data, cmd->len, NULL);
2263
+
+ transfer->short_is_error = TRUE;
2264
+
+ break;
2265
+
+ case CMD_BULK_IN:
2266
+
+ fp_dbg("[%s] cmd %d/%d %s len=%zu",
2267
+
+ ctx->seq_name,
2268
+
+ ctx->cmd_index + 1,
2269
+
+ ctx->cmd_total,
2270
+
+ cb2000_cmd_type_to_str(cmd->type),
2271
+
+ cmd->len);
2272
+
+ fpi_usb_transfer_fill_bulk(transfer, CB2000_EP_IN, cmd->len);
2273
+
+ break;
2274
+
+ case CMD_CTRL_OUT:
2275
+
+ fp_dbg("[%s] cmd %d/%d %s req=0x%02x value=0x%04x index=%u",
2276
+
+ ctx->seq_name,
2277
+
+ ctx->cmd_index + 1,
2278
+
+ ctx->cmd_total,
2279
+
+ cb2000_cmd_type_to_str(cmd->type),
2280
+
+ cmd->request, cmd->value, cmd->index);
2281
+
+ fpi_usb_transfer_fill_control(transfer,
2282
+
+ G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
2283
+
+ G_USB_DEVICE_REQUEST_TYPE_VENDOR,
2284
+
+ G_USB_DEVICE_RECIPIENT_DEVICE,
2285
+
+ cmd->request, cmd->value, cmd->index, 0);
2286
+
+ break;
2287
+
+ case CMD_CTRL_IN:
2288
+
+ fp_dbg("[%s] cmd %d/%d %s req=0x%02x value=0x%04x index=%u len=%zu",
2289
+
+ ctx->seq_name,
2290
+
+ ctx->cmd_index + 1,
2291
+
+ ctx->cmd_total,
2292
+
+ cb2000_cmd_type_to_str(cmd->type),
2293
+
+ cmd->request, cmd->value, cmd->index, cmd->len);
2294
+
+ fpi_usb_transfer_fill_control(transfer,
2295
+
+ G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
2296
+
+ G_USB_DEVICE_REQUEST_TYPE_VENDOR,
2297
+
+ G_USB_DEVICE_RECIPIENT_DEVICE,
2298
+
+ cmd->request, cmd->value, cmd->index,
2299
+
+ cmd->len);
2300
+
+ break;
2301
+
+ case CMD_END:
2302
+
+ g_assert_not_reached();
2303
+
+ return;
2304
+
+ }
2305
+
+
2306
+
+ fpi_usb_transfer_submit(transfer, CB2000_TIMEOUT, NULL,
2307
+
+ cmd_transfer_cb, NULL);
2308
+
+}
2309
+
+
2310
+
+/*
2311
+
+ * Command transfer completion: on success, advance to the next command;
2312
+
+ * on failure, abort the sequence and bubble up the error.
2313
+
+ */
2314
+
+static void
2315
+
+cmd_transfer_cb(FpiUsbTransfer *transfer,
2316
+
+ FpDevice *dev,
2317
+
+ gpointer user_data,
2318
+
+ GError *error)
2319
+
+{
2320
+
+ Cb2000CmdContext *ctx;
2321
+
+ const Cb2000Command *cmd;
2322
+
+
2323
+
+ if (error) {
2324
+
+ fp_warn("Command transfer failed: %s", error->message);
2325
+
+ fpi_ssm_mark_failed(transfer->ssm, error);
2326
+
+ return;
2327
+
+ }
2328
+
+
2329
+
+ ctx = fpi_ssm_get_data(transfer->ssm);
2330
+
+ cmd = &ctx->commands[ctx->cmd_index];
2331
+
+ cb2000_log_cmd_rx_data(dev, ctx, cmd, transfer);
2332
+
+ ctx->cmd_index++;
2333
+
+ fpi_ssm_jump_to_state(transfer->ssm, 0);
2334
+
+}
2335
+
+
2336
+
+/* ============================================================================
2337
+
+ * USB TRANSFER HELPERS
2338
+
+ * ============================================================================ */
2339
+
+
2340
+
+/*
2341
+
+ * Submit a vendor control IN request and bind it to an SSM.
2342
+
+ * The SSM will keep ownership of the transfer lifecycle.
2343
+
+ */
2344
+
+static void
2345
+
+cb2000_ctrl_in(FpDevice *dev,
2346
+
+ FpiSsm *ssm,
2347
+
+ guint8 request,
2348
+
+ guint16 value,
2349
+
+ guint16 index,
2350
+
+ gsize len,
2351
+
+ FpiUsbTransferCallback callback,
2352
+
+ gpointer user_data)
2353
+
+{
2354
+
+ FpiUsbTransfer *transfer = fpi_usb_transfer_new(dev);
2355
+
+
2356
+
+ fpi_usb_transfer_fill_control(transfer,
2357
+
+ G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
2358
+
+ G_USB_DEVICE_REQUEST_TYPE_VENDOR,
2359
+
+ G_USB_DEVICE_RECIPIENT_DEVICE,
2360
+
+ request, value, index, len);
2361
+
+ transfer->ssm = ssm;
2362
+
+ fpi_usb_transfer_submit(transfer, CB2000_TIMEOUT, NULL,
2363
+
+ callback, user_data);
2364
+
+}
2365
+
+
2366
+
+/*
2367
+
+ * Submit a bulk read for a fixed-length chunk from the sensor.
2368
+
+ */
2369
+
+static void
2370
+
+cb2000_bulk_read(FpDevice *dev,
2371
+
+ FpiSsm *ssm,
2372
+
+ gsize len,
2373
+
+ FpiUsbTransferCallback callback,
2374
+
+ gpointer user_data)
2375
+
+{
2376
+
+ FpiUsbTransfer *transfer = fpi_usb_transfer_new(dev);
2377
+
+
2378
+
+ fpi_usb_transfer_fill_bulk(transfer, CB2000_EP_IN, len);
2379
+
+ transfer->ssm = ssm;
2380
+
+ fpi_usb_transfer_submit(transfer, CB2000_TIMEOUT, NULL,
2381
+
+ callback, user_data);
2382
+
+}
2383
+
+
2384
+
+/*
2385
+
+ * Submit a bulk write. Used for padding "keepalive" writes between reads.
2386
+
+ */
2387
+
+static void
2388
+
+cb2000_bulk_write(FpDevice *dev,
2389
+
+ FpiSsm *ssm,
2390
+
+ const guint8 *data,
2391
+
+ gsize len,
2392
+
+ FpiUsbTransferCallback callback,
2393
+
+ gpointer user_data)
2394
+
+{
2395
+
+ FpiUsbTransfer *transfer = fpi_usb_transfer_new(dev);
2396
+
+
2397
+
+ fpi_usb_transfer_fill_bulk_full(transfer, CB2000_EP_OUT,
2398
+
+ (guint8 *)data, len, NULL);
2399
+
+ transfer->ssm = ssm;
2400
+
+ transfer->short_is_error = TRUE;
2401
+
+ fpi_usb_transfer_submit(transfer, CB2000_TIMEOUT, NULL,
2402
+
+ callback, user_data);
2403
+
+}
2404
+
+
2405
+
+/* ============================================================================
2406
+
+ * ACTIVATION SUB-SSM
2407
+
+ * ============================================================================ */
2408
+
+
2409
+
+static void
2410
+
+activate_run_state(FpiSsm *ssm, FpDevice *dev)
2411
+
+{
2412
+
+ switch (fpi_ssm_get_cur_state(ssm)) {
2413
+
+ case STATE_ACTIVATE_WAKE_SEQ:
2414
+
+ fp_dbg("Activation: WAKE_SEQ (9 commands)");
2415
+
+ run_command_sequence(ssm, dev, "activation_wake", activation_wake_cmds);
2416
+
+ break;
2417
+
+ case STATE_ACTIVATE_REGS_SEQ:
2418
+
+ fp_dbg("Activation: REGS_SEQ (42 commands)");
2419
+
+ run_command_sequence(ssm, dev, "activation_regs", activation_regs_cmds);
2420
+
+ break;
2421
+
+ case STATE_ACTIVATE_TRIGGER_SEQ:
2422
+
+ fp_dbg("Activation: TRIGGER_SEQ (7 commands)");
2423
+
+ run_command_sequence(ssm, dev, "activation_trigger", activation_trigger_cmds);
2424
+
+ break;
2425
+
+ case STATE_ACTIVATE_CAPTURE_SEQ:
2426
+
+ fp_dbg("Activation: CAPTURE_SEQ (27 commands)");
2427
+
+ run_command_sequence(ssm, dev, "activation_capture", activation_capture_cmds);
2428
+
+ break;
2429
+
+ case STATE_ACTIVATE_FINALIZE_SEQ:
2430
+
+ fp_dbg("Activation: FINALIZE_SEQ (11 commands)");
2431
+
+ run_command_sequence(ssm, dev, "activation_finalize", activation_finalize_cmds);
2432
+
+ break;
2433
+
+ }
2434
+
+}
2435
+
+
2436
+
+/* ============================================================================
2437
+
+ * FINGER POLLING SUB-SSM
2438
+
+ * ============================================================================ */
2439
+
+
2440
+
+static void poll_finger_run_state(FpiSsm *ssm, FpDevice *dev);
2441
+
+
2442
+
+/*
2443
+
+ * Delay step for finger polling. This keeps the polling period stable and
2444
+
+ * avoids hammering the USB control endpoint.
2445
+
+ */
2446
+
+static gboolean
2447
+
+poll_finger_delay_cb(gpointer user_data)
2448
+
+{
2449
+
+ FpiSsm *ssm = user_data;
2450
+
+ FpDevice *dev = fpi_ssm_get_device(ssm);
2451
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
2452
+
+
2453
+
+ self->poll_timeout_id = 0;
2454
+
+
2455
+
+ if (self->deactivating || self->deactivation_in_progress) {
2456
+
+ return G_SOURCE_REMOVE;
2457
+
+ }
2458
+
+
2459
+
+ fpi_ssm_next_state(ssm);
2460
+
+ return G_SOURCE_REMOVE;
2461
+
+}
2462
+
+
2463
+
+/*
2464
+
+ * Poll response handler. Implements debounce and stale-timeout detection.
2465
+
+ * The device reports finger presence via two status bytes; we treat either
2466
+
+ * bit as a valid presence signal for safety.
2467
+
+ */
2468
+
+static void
2469
+
+poll_finger_result_cb(FpiUsbTransfer *transfer,
2470
+
+ FpDevice *dev,
2471
+
+ gpointer user_data,
2472
+
+ GError *error)
2473
+
+{
2474
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
2475
+
+ gint64 now_us = g_get_monotonic_time();
2476
+
+
2477
+
+ if (self->deactivating || self->deactivation_in_progress) {
2478
+
+ return;
2479
+
+ }
2480
+
+ if (error) {
2481
+
+ fpi_ssm_mark_failed(transfer->ssm, error);
2482
+
+ return;
2483
+
+ }
2484
+
+
2485
+
+ if (transfer->actual_length < 2) {
2486
+
+ fp_dbg("Poll: short read (%zu bytes), retrying",
2487
+
+ transfer->actual_length);
2488
+
+ fpi_ssm_jump_to_state(transfer->ssm, POLL_FINGER_DELAY);
2489
+
+ return;
2490
+
+ }
2491
+
+
2492
+
+ /* The device can signal presence via either byte. */
2493
+
+ gboolean finger_present = (transfer->buffer[1] != 0) ||
2494
+
+ (transfer->buffer[0] == 0x01);
2495
+
+ self->poll_total_count++;
2496
+
+
2497
+
+ fp_dbg("Poll response: len=%zu [0]=%02x [1]=%02x (hits=%d streak=%d)",
2498
+
+ transfer->actual_length,
2499
+
+ transfer->buffer[0], transfer->buffer[1],
2500
+
+ self->poll_stable_hits, self->no_finger_streak);
2501
+
+ if (self->poll_total_count == 0) {
2502
+
+ fp_dbg("WAIT_FINGER started: t0=%" G_GINT64_FORMAT "us",
2503
+
+ self->poll_start_us);
2504
+
+ }
2505
+
+
2506
+
+ if (self->poll_total_count > 0 && (self->poll_total_count % 10) == 0) {
2507
+
+ fp_dbg("WAIT_FINGER timing: poll=%u t=+%" G_GINT64_FORMAT "us",
2508
+
+ self->poll_total_count, (now_us - self->poll_start_us));
2509
+
+ }
2510
+
+
2511
+
+ if ((now_us - self->poll_start_us) >
2512
+
+ (gint64)CB2000_POLL_STALE_TIMEOUT_MS * 1000) {
2513
+
+ fp_warn("WAIT_FINGER stale (>%dms) - triggering recovery",
2514
+
+ CB2000_POLL_STALE_TIMEOUT_MS);
2515
+
+ fpi_ssm_mark_failed(transfer->ssm,
2516
+
+ fpi_device_error_new_msg(FP_DEVICE_ERROR_PROTO,
2517
+
+ "Finger polling stale"));
2518
+
+ return;
2519
+
+ }
2520
+
+
2521
+
+ if (finger_present) {
2522
+
+ self->no_finger_streak = 0;
2523
+
+ self->poll_stable_hits++;
2524
+
+
2525
+
+ /* Disabled for Windows parity (no early-placement delay). */
2526
+
+ if (self->poll_total_count <= CB2000_EARLY_PLACEMENT_POLLS) {
2527
+
+ fp_dbg("Early placement gate disabled (poll=%d)",
2528
+
+ self->poll_total_count);
2529
+
+ }
2530
+
+
2531
+
+ if (self->poll_stable_hits >= CB2000_POLL_DEBOUNCE_COUNT) {
2532
+
+ fp_dbg("Finger detected (stable, hits=%d)", self->poll_stable_hits);
2533
+
+ fpi_ssm_mark_completed(transfer->ssm);
2534
+
+ return;
2535
+
+ }
2536
+
+
2537
+
+ fp_dbg("Finger detected but debouncing (%d/%d)",
2538
+
+ self->poll_stable_hits, CB2000_POLL_DEBOUNCE_COUNT);
2539
+
+ } else {
2540
+
+ self->poll_stable_hits = 0;
2541
+
+ self->no_finger_streak++;
2542
+
+ }
2543
+
+
2544
+
+ /* Loop: back to delay */
2545
+
+ fpi_ssm_jump_to_state(transfer->ssm, POLL_FINGER_DELAY);
2546
+
+}
2547
+
+
2548
+
+/*
2549
+
+ * Polling sub-SSM entry point. Alternates between a fixed delay and a
2550
+
+ * control IN request.
2551
+
+ */
2552
+
+static void
2553
+
+poll_finger_run_state(FpiSsm *ssm, FpDevice *dev)
2554
+
+{
2555
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
2556
+
+
2557
+
+ if (self->deactivating || self->deactivation_in_progress) {
2558
+
+ return;
2559
+
+ }
2560
+
+
2561
+
+ switch (fpi_ssm_get_cur_state(ssm)) {
2562
+
+ case POLL_FINGER_DELAY:
2563
+
+ self->poll_timeout_id = g_timeout_add(CB2000_POLL_INTERVAL,
2564
+
+ poll_finger_delay_cb, ssm);
2565
+
+ break;
2566
+
+ case POLL_FINGER_SEND:
2567
+
+ fp_dbg("Polling REQ_POLL (wValue=0x0007 wIndex=0 len=2)");
2568
+
+ cb2000_ctrl_in(dev, ssm,
2569
+
+ REQ_POLL, 0x0007, 0, 2,
2570
+
+ poll_finger_result_cb, NULL);
2571
+
+ break;
2572
+
+ }
2573
+
+}
2574
+
+
2575
+
+/* ============================================================================
2576
+
+ * REMOVAL POLLING SUB-SSM
2577
+
+ * ============================================================================ */
2578
+
+
2579
+
+static void poll_removal_run_state(FpiSsm *ssm, FpDevice *dev);
2580
+
+
2581
+
+/*
2582
+
+ * Delay step for finger removal polling. Uses a longer interval to reduce
2583
+
+ * USB traffic once an image has already been captured.
2584
+
+ */
2585
+
+static gboolean
2586
+
+poll_removal_delay_cb(gpointer user_data)
2587
+
+{
2588
+
+ FpiSsm *ssm = user_data;
2589
+
+ FpDevice *dev = fpi_ssm_get_device(ssm);
2590
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
2591
+
+
2592
+
+ self->removal_timeout_id = 0;
2593
+
+
2594
+
+ if (self->deactivating || self->deactivation_in_progress) {
2595
+
+ return G_SOURCE_REMOVE;
2596
+
+ }
2597
+
+
2598
+
+ fpi_ssm_next_state(ssm);
2599
+
+ return G_SOURCE_REMOVE;
2600
+
+}
2601
+
+
2602
+
+/*
2603
+
+ * Removal response handler. Requires N consecutive "no finger" readings
2604
+
+ * to declare removal, to avoid flicker.
2605
+
+ */
2606
+
+static void
2607
+
+poll_removal_result_cb(FpiUsbTransfer *transfer,
2608
+
+ FpDevice *dev,
2609
+
+ gpointer user_data,
2610
+
+ GError *error)
2611
+
+{
2612
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
2613
+
+ gint64 now_us = g_get_monotonic_time();
2614
+
+
2615
+
+ if (self->deactivating || self->deactivation_in_progress) {
2616
+
+ return;
2617
+
+ }
2618
+
+ if (error) {
2619
+
+ fpi_ssm_mark_failed(transfer->ssm, error);
2620
+
+ return;
2621
+
+ }
2622
+
+
2623
+
+ if (transfer->actual_length < 2) {
2624
+
+ fpi_ssm_jump_to_state(transfer->ssm, POLL_REMOVAL_DELAY);
2625
+
+ return;
2626
+
+ }
2627
+
+
2628
+
+ gboolean finger_present = (transfer->buffer[1] != 0);
2629
+
+ fp_dbg("Removal poll: [0]=%02x [1]=%02x finger_present=%d",
2630
+
+ transfer->buffer[0], transfer->buffer[1], finger_present);
2631
+
+
2632
+
+ self->removal_poll_count++;
2633
+
+
2634
+
+ if ((now_us - self->removal_start_us) >
2635
+
+ (gint64)CB2000_REMOVAL_STALE_TIMEOUT_MS * 1000) {
2636
+
+ fp_warn("WAIT_REMOVAL stale (>%dms) - triggering recovery",
2637
+
+ CB2000_REMOVAL_STALE_TIMEOUT_MS);
2638
+
+ fpi_ssm_mark_failed(transfer->ssm,
2639
+
+ fpi_device_error_new_msg(FP_DEVICE_ERROR_PROTO,
2640
+
+ "Removal polling stale"));
2641
+
+ return;
2642
+
+ }
2643
+
+
2644
+
+ if (finger_present) {
2645
+
+ self->removal_stable_off_hits = 0;
2646
+
+ fpi_ssm_jump_to_state(transfer->ssm, POLL_REMOVAL_DELAY);
2647
+
+ } else {
2648
+
+ self->removal_stable_off_hits++;
2649
+
+ if (self->removal_stable_off_hits < CB2000_REMOVAL_STABLE_OFF_COUNT) {
2650
+
+ fp_dbg("Removal debounce: off hits %d/%d",
2651
+
+ self->removal_stable_off_hits,
2652
+
+ CB2000_REMOVAL_STABLE_OFF_COUNT);
2653
+
+ fpi_ssm_jump_to_state(transfer->ssm, POLL_REMOVAL_DELAY);
2654
+
+ return;
2655
+
+ }
2656
+
+
2657
+
+ fp_dbg("Finger removed, reporting status");
2658
+
+ if (!self->deactivating && !self->deactivation_in_progress)
2659
+
+ fpi_ssm_mark_completed(transfer->ssm);
2660
+
+ }
2661
+
+}
2662
+
+
2663
+
+/*
2664
+
+ * Removal polling sub-SSM entry point.
2665
+
+ */
2666
+
+static void
2667
+
+poll_removal_run_state(FpiSsm *ssm, FpDevice *dev)
2668
+
+{
2669
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
2670
+
+
2671
+
+ if (self->deactivating || self->deactivation_in_progress) {
2672
+
+ return;
2673
+
+ }
2674
+
+
2675
+
+ switch (fpi_ssm_get_cur_state(ssm)) {
2676
+
+ case POLL_REMOVAL_DELAY:
2677
+
+ self->removal_timeout_id = g_timeout_add(CB2000_REMOVAL_INTERVAL,
2678
+
+ poll_removal_delay_cb, ssm);
2679
+
+ break;
2680
+
+ case POLL_REMOVAL_SEND:
2681
+
+ cb2000_ctrl_in(dev, ssm,
2682
+
+ REQ_POLL, 0x0007, 0, 2,
2683
+
+ poll_removal_result_cb, NULL);
2684
+
+ break;
2685
+
+ }
2686
+
+}
2687
+
+
2688
+
+/* ============================================================================
2689
+
+ * IMAGE READ SUB-SSM
2690
+
+ * ============================================================================ */
2691
+
+
2692
+
+static void image_read_run_state(FpiSsm *ssm, FpDevice *dev);
2693
+
+
2694
+
+/*
2695
+
+ * CLAHE (Contrast Limited Adaptive Histogram Equalization).
2696
+
+ * Enhances local contrast per tile, so ridge/valley boundaries are sharpened
2697
+
+ * without the global flattening that a full-image equalization would cause.
2698
+
+ *
2699
+
+ * Applied on the RAW 80x64 image BEFORE upscale. This is the single most
2700
+
+ * important preprocessing step for NBIS minutiae detection on small sensors:
2701
+
+ * it makes ridges locally contrasty so MINDTCT can compute direction maps.
2702
+
+ *
2703
+
+ * Grid: tiles_x * tiles_y tiles of tile_w * tile_h pixels each.
2704
+
+ * clip_limit controls how much contrast amplification is allowed per tile
2705
+
+ * (higher = more contrast, but also more noise amplification).
2706
+
+ * Bilinear interpolation between neighboring tile histograms avoids
2707
+
+ * visible tile boundary artifacts.
2708
+
+ */
2709
+
+static void
2710
+
+apply_clahe(guint8 *data, gint width, gint height,
2711
+
+ gint tile_w, gint tile_h, double clip_limit)
2712
+
+{
2713
+
+ gint tiles_x = width / tile_w;
2714
+
+ gint tiles_y = height / tile_h;
2715
+
+
2716
+
+ if (tiles_x < 2 || tiles_y < 2)
2717
+
+ return;
2718
+
+
2719
+
+ gint num_tiles = tiles_x * tiles_y;
2720
+
+ gint tile_size = tile_w * tile_h;
2721
+
+
2722
+
+ /* Build per-tile CDF lookup tables */
2723
+
+ guint8 *lut = g_malloc(num_tiles * 256);
2724
+
+
2725
+
+ for (gint ty = 0; ty < tiles_y; ty++) {
2726
+
+ for (gint tx = 0; tx < tiles_x; tx++) {
2727
+
+ gint hist[256] = {0};
2728
+
+ gint tile_idx = ty * tiles_x + tx;
2729
+
+
2730
+
+ /* Compute histogram for this tile */
2731
+
+ for (gint dy = 0; dy < tile_h; dy++) {
2732
+
+ gint y = ty * tile_h + dy;
2733
+
+ for (gint dx = 0; dx < tile_w; dx++) {
2734
+
+ gint x = tx * tile_w + dx;
2735
+
+ hist[data[y * width + x]]++;
2736
+
+ }
2737
+
+ }
2738
+
+
2739
+
+ /* Clip histogram (redistribute excess above clip threshold) */
2740
+
+ gint clip_threshold = (gint)(clip_limit * tile_size / 256);
2741
+
+ if (clip_threshold < 1)
2742
+
+ clip_threshold = 1;
2743
+
+
2744
+
+ gint excess = 0;
2745
+
+ for (gint i = 0; i < 256; i++) {
2746
+
+ if (hist[i] > clip_threshold) {
2747
+
+ excess += hist[i] - clip_threshold;
2748
+
+ hist[i] = clip_threshold;
2749
+
+ }
2750
+
+ }
2751
+
+ /* Redistribute excess evenly */
2752
+
+ gint per_bin = excess / 256;
2753
+
+ gint remainder = excess - per_bin * 256;
2754
+
+ for (gint i = 0; i < 256; i++)
2755
+
+ hist[i] += per_bin;
2756
+
+ /* Spread remainder across bins */
2757
+
+ for (gint i = 0; i < remainder; i++)
2758
+
+ hist[i]++;
2759
+
+
2760
+
+ /* Build CDF -> LUT mapping */
2761
+
+ gint cumulative = 0;
2762
+
+ for (gint i = 0; i < 256; i++) {
2763
+
+ cumulative += hist[i];
2764
+
+ lut[tile_idx * 256 + i] =
2765
+
+ (guint8)((cumulative * 255) / tile_size);
2766
+
+ }
2767
+
+ }
2768
+
+ }
2769
+
+
2770
+
+ /* Apply with bilinear interpolation between tiles */
2771
+
+ guint8 *out = g_malloc(width * height);
2772
+
+
2773
+
+ for (gint y = 0; y < height; y++) {
2774
+
+ for (gint x = 0; x < width; x++) {
2775
+
+ guint8 pixel = data[y * width + x];
2776
+
+
2777
+
+ /* Find which tile center this pixel is nearest to */
2778
+
+ double fx = ((double)x - tile_w * 0.5) / tile_w;
2779
+
+ double fy = ((double)y - tile_h * 0.5) / tile_h;
2780
+
+
2781
+
+ gint tx0 = (gint)fx;
2782
+
+ gint ty0 = (gint)fy;
2783
+
+
2784
+
+ if (tx0 < 0) tx0 = 0;
2785
+
+ if (ty0 < 0) ty0 = 0;
2786
+
+ if (tx0 >= tiles_x - 1) tx0 = tiles_x - 2;
2787
+
+ if (ty0 >= tiles_y - 1) ty0 = tiles_y - 2;
2788
+
+
2789
+
+ gint tx1 = tx0 + 1;
2790
+
+ gint ty1 = ty0 + 1;
2791
+
+
2792
+
+ double ax = fx - tx0;
2793
+
+ double ay = fy - ty0;
2794
+
+ if (ax < 0.0) ax = 0.0;
2795
+
+ if (ax > 1.0) ax = 1.0;
2796
+
+ if (ay < 0.0) ay = 0.0;
2797
+
+ if (ay > 1.0) ay = 1.0;
2798
+
+
2799
+
+ /* Bilinear interpolation of 4 neighboring tile LUTs */
2800
+
+ double v00 = lut[(ty0 * tiles_x + tx0) * 256 + pixel];
2801
+
+ double v10 = lut[(ty0 * tiles_x + tx1) * 256 + pixel];
2802
+
+ double v01 = lut[(ty1 * tiles_x + tx0) * 256 + pixel];
2803
+
+ double v11 = lut[(ty1 * tiles_x + tx1) * 256 + pixel];
2804
+
+
2805
+
+ double val = v00 * (1 - ax) * (1 - ay) +
2806
+
+ v10 * ax * (1 - ay) +
2807
+
+ v01 * (1 - ax) * ay +
2808
+
+ v11 * ax * ay;
2809
+
+
2810
+
+ out[y * width + x] = (guint8)(val + 0.5);
2811
+
+ }
2812
+
+ }
2813
+
+
2814
+
+ memcpy(data, out, width * height);
2815
+
+ g_free(out);
2816
+
+ g_free(lut);
2817
+
+
2818
+
+ fp_dbg("CLAHE applied: %dx%d tiles, clip=%.1f",
2819
+
+ tiles_x, tiles_y, clip_limit);
2820
+
+}
2821
+
+
2822
+
+/*
2823
+
+ * Smart levels: percentile-based contrast stretch.
2824
+
+ * Clips bottom/top 5% of histogram before stretching, so outlier pixels
2825
+
+ * (stuck pixels, noise spikes) don't compress the useful ridge contrast.
2826
+
+ */
2827
+
+static void
2828
+
+normalize_contrast(guint8 *data, gint width, gint height)
2829
+
+{
2830
+
+ gint size = width * height;
2831
+
+ gint hist[256] = {0};
2832
+
+
2833
+
+ for (gint i = 0; i < size; i++)
2834
+
+ hist[data[i]]++;
2835
+
+
2836
+
+ /* Find 5th and 95th percentile values */
2837
+
+ gint clip_lo_count = (gint)(size * 0.05);
2838
+
+ gint clip_hi_count = (gint)(size * 0.05);
2839
+
+ guint8 lo = 0, hi = 255;
2840
+
+ gint cumulative = 0;
2841
+
+
2842
+
+ for (gint v = 0; v < 256; v++) {
2843
+
+ cumulative += hist[v];
2844
+
+ if (cumulative > clip_lo_count) {
2845
+
+ lo = (guint8)v;
2846
+
+ break;
2847
+
+ }
2848
+
+ }
2849
+
+
2850
+
+ cumulative = 0;
2851
+
+ for (gint v = 255; v >= 0; v--) {
2852
+
+ cumulative += hist[v];
2853
+
+ if (cumulative > clip_hi_count) {
2854
+
+ hi = (guint8)v;
2855
+
+ break;
2856
+
+ }
2857
+
+ }
2858
+
+
2859
+
+ if (hi <= lo)
2860
+
+ return;
2861
+
+
2862
+
+ fp_dbg("Smart levels: lo=%d hi=%d (clipped 5%%/95%%)", lo, hi);
2863
+
+
2864
+
+ double range = (double)(hi - lo);
2865
+
+ for (gint i = 0; i < size; i++) {
2866
+
+ if (data[i] <= lo)
2867
+
+ data[i] = 0;
2868
+
+ else if (data[i] >= hi)
2869
+
+ data[i] = 255;
2870
+
+ else
2871
+
+ data[i] = (guint8)(((data[i] - lo) * 255.0) / range);
2872
+
+ }
2873
+
+}
2874
+
+
2875
+
+/*
2876
+
+ * 3x3 Gaussian blur (sigma ~0.85) to smooth bilinear upscale artifacts.
2877
+
+ * Kernel: [1 2 1; 2 4 2; 1 2 1] / 16
2878
+
+ * Only applied to upscaled images - smooths blocky pixel grid into
2879
+
+ * more natural ridge contours for NBIS.
2880
+
+ */
2881
+
+static void
2882
+
+gaussian_blur_3x3(guint8 *data, gint width, gint height)
2883
+
+{
2884
+
+ guint8 *tmp = g_malloc(width * height);
2885
+
+
2886
+
+ memcpy(tmp, data, width * height);
2887
+
+
2888
+
+ for (gint y = 1; y < height - 1; y++) {
2889
+
+ for (gint x = 1; x < width - 1; x++) {
2890
+
+ gint sum =
2891
+
+ 1 * tmp[(y - 1) * width + (x - 1)] +
2892
+
+ 2 * tmp[(y - 1) * width + x] +
2893
+
+ 1 * tmp[(y - 1) * width + (x + 1)] +
2894
+
+ 2 * tmp[y * width + (x - 1)] +
2895
+
+ 4 * tmp[y * width + x] +
2896
+
+ 2 * tmp[y * width + (x + 1)] +
2897
+
+ 1 * tmp[(y + 1) * width + (x - 1)] +
2898
+
+ 2 * tmp[(y + 1) * width + x] +
2899
+
+ 1 * tmp[(y + 1) * width + (x + 1)];
2900
+
+ data[y * width + x] = (guint8)(sum / 16);
2901
+
+ }
2902
+
+ }
2903
+
+
2904
+
+ g_free(tmp);
2905
+
+}
2906
+
+
2907
+
+static double
2908
+
+calculate_variance(const guint8 *data, gint width, gint height)
2909
+
+{
2910
+
+ gint size = width * height;
2911
+
+ double mean = 0.0;
2912
+
+
2913
+
+ for (gint i = 0; i < size; i++)
2914
+
+ mean += data[i];
2915
+
+ mean /= size;
2916
+
+
2917
+
+ double var = 0.0;
2918
+
+ for (gint i = 0; i < size; i++) {
2919
+
+ double diff = data[i] - mean;
2920
+
+ var += diff * diff;
2921
+
+ }
2922
+
+
2923
+
+ return var / size;
2924
+
+}
2925
+
+
2926
+
+static double
2927
+
+calculate_block_low_var_ratio(const guint8 *data,
2928
+
+ gint width,
2929
+
+ gint height,
2930
+
+ gint block_size,
2931
+
+ double var_threshold)
2932
+
+{
2933
+
+ gint blocks_x = width / block_size;
2934
+
+ gint blocks_y = height / block_size;
2935
+
+ gint total_blocks = blocks_x * blocks_y;
2936
+
+ gint low_blocks = 0;
2937
+
+
2938
+
+ if (total_blocks == 0)
2939
+
+ return 0.0;
2940
+
+
2941
+
+ for (gint by = 0; by < blocks_y; by++) {
2942
+
+ for (gint bx = 0; bx < blocks_x; bx++) {
2943
+
+ double sum = 0.0;
2944
+
+ double sum2 = 0.0;
2945
+
+ for (gint y = 0; y < block_size; y++) {
2946
+
+ gint row = (by * block_size + y) * width;
2947
+
+ for (gint x = 0; x < block_size; x++) {
2948
+
+ guint8 v = data[row + (bx * block_size + x)];
2949
+
+ sum += v;
2950
+
+ sum2 += (double)v * (double)v;
2951
+
+ }
2952
+
+ }
2953
+
+ double n = (double)block_size * (double)block_size;
2954
+
+ double mean = sum / n;
2955
+
+ double var = (sum2 / n) - (mean * mean);
2956
+
+ if (var < var_threshold)
2957
+
+ low_blocks++;
2958
+
+ }
2959
+
+ }
2960
+
+
2961
+
+ return (double)low_blocks / (double)total_blocks;
2962
+
+}
2963
+
+
2964
+
+static double
2965
+
+calculate_laplacian_variance(const guint8 *data, gint width, gint height)
2966
+
+{
2967
+
+ double sum = 0.0;
2968
+
+ double sum2 = 0.0;
2969
+
+ gint count = 0;
2970
+
+
2971
+
+ if (width < 3 || height < 3)
2972
+
+ return 0.0;
2973
+
+
2974
+
+ for (gint y = 1; y < height - 1; y++) {
2975
+
+ for (gint x = 1; x < width - 1; x++) {
2976
+
+ gint idx = y * width + x;
2977
+
+ gint l = data[idx - width] + data[idx + width] +
2978
+
+ data[idx - 1] + data[idx + 1] -
2979
+
+ 4 * data[idx];
2980
+
+ sum += l;
2981
+
+ sum2 += (double)l * (double)l;
2982
+
+ count++;
2983
+
+ }
2984
+
+ }
2985
+
+
2986
+
+ if (count == 0)
2987
+
+ return 0.0;
2988
+
+
2989
+
+ double mean = sum / count;
2990
+
+ return (sum2 / count) - (mean * mean);
2991
+
+}
2992
+
+
2993
+
+/*
2994
+
+ * Approximate fingerprint coverage area (0.0..1.0).
2995
+
+ * This is a host-side proxy for the DLL notion of "fingerprint_area":
2996
+
+ * blocks with enough local variance are considered fingerprint foreground.
2997
+
+ */
2998
+
+static double
2999
+
+calculate_fingerprint_area_ratio(const guint8 *data, gint width, gint height)
3000
+
+{
3001
+
+ double low_var_ratio = calculate_block_low_var_ratio(data, width, height,
3002
+
+ CB2000_BLOCK_SIZE,
3003
+
+ CB2000_LOW_VAR_THRESHOLD);
3004
+
+ return CLAMP(1.0 - low_var_ratio, 0.0, 1.0);
3005
+
+}
3006
+
+
3007
+
+/*
3008
+
+ * Approximate overlap percentage between consecutive normalized frames.
3009
+
+ * The metric is intentionally simple and only used as a retry heuristic log.
3010
+
+ * Returns -1 when overlap is undefined (no previous foreground data).
3011
+
+ */
3012
+
+static int
3013
+
+calculate_overlap_percent(const guint8 *curr, const guint8 *prev, gint size)
3014
+
+{
3015
+
+ gint curr_fg = 0;
3016
+
+ gint prev_fg = 0;
3017
+
+ gint inter = 0;
3018
+
+
3019
+
+ for (gint i = 0; i < size; i++) {
3020
+
+ gboolean c = curr[i] > CB2000_FOREGROUND_THRESHOLD;
3021
+
+ gboolean p = prev[i] > CB2000_FOREGROUND_THRESHOLD;
3022
+
+ if (c)
3023
+
+ curr_fg++;
3024
+
+ if (p)
3025
+
+ prev_fg++;
3026
+
+ if (c && p)
3027
+
+ inter++;
3028
+
+ }
3029
+
+
3030
+
+ gint denom = MIN(curr_fg, prev_fg);
3031
+
+ if (denom <= 0)
3032
+
+ return -1;
3033
+
+
3034
+
+ return (inter * 100) / denom;
3035
+
+}
3036
+
+
3037
+
+/*
3038
+
+ * Coarse quality score (0..100) to mirror DLL-style host quality diagnostics.
3039
+
+ * The score blends global variance, focus (Laplacian variance), and area ratio.
3040
+
+ */
3041
+
+static int
3042
+
+calculate_quality_score(double variance_norm, double focus_var, double area_ratio)
3043
+
+{
3044
+
+ double var_n = CLAMP(variance_norm / 5000.0, 0.0, 1.0);
3045
+
+ double focus_n = CLAMP(focus_var / 1500.0, 0.0, 1.0);
3046
+
+ double area_n = CLAMP(area_ratio, 0.0, 1.0);
3047
+
+ double score = (0.40 * var_n + 0.35 * focus_n + 0.25 * area_n) * 100.0;
3048
+
+ return (int)CLAMP(score, 0.0, 100.0);
3049
+
+}
3050
+
+
3051
+
+static void
3052
+
+apply_background_subtraction(guint8 *data,
3053
+
+ const guint8 *bg,
3054
+
+ gint width,
3055
+
+ gint height)
3056
+
+{
3057
+
+ gint size = width * height;
3058
+
+ for (gint i = 0; i < size; i++) {
3059
+
+ if (data[i] > bg[i])
3060
+
+ data[i] = (guint8)(data[i] - bg[i]);
3061
+
+ else
3062
+
+ data[i] = 0;
3063
+
+ }
3064
+
+}
3065
+
+
3066
+
+/*
3067
+
+ * Read one image chunk.
3068
+
+ *
3069
+
+ * Windows captures show mixed packet lengths depending on transport mode:
3070
+
+ * - legacy framing: 320-byte chunk carrying 256-byte payload at offset 64
3071
+
+ * - compact framing: mostly 256-byte chunks, with a trailing 259-byte chunk
3072
+
+ *
3073
+
+ * In compact framing, the first chunk can start with a 3-byte marker
3074
+
+ * (typically ff 00 06). When present, those bytes are framing metadata and
3075
+
+ * must be skipped to keep image assembly aligned with Windows.
3076
+
+ *
3077
+
+ * CB2000_CHUNK_PAYLOAD_OFFSET can still force a static offset for experiments.
3078
+
+ */
3079
+
+static void
3080
+
+image_chunk_cb(FpiUsbTransfer *transfer,
3081
+
+ FpDevice *dev,
3082
+
+ gpointer user_data,
3083
+
+ GError *error)
3084
+
+{
3085
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
3086
+
+
3087
+
+ if (error) {
3088
+
+ fp_warn("Image chunk read error: %s", error->message);
3089
+
+ fpi_ssm_mark_failed(transfer->ssm, error);
3090
+
+ return;
3091
+
+ }
3092
+
+
3093
+
+ guint8 *src = transfer->buffer;
3094
+
+ gsize len = transfer->actual_length;
3095
+
+ int chunk_index = self->chunks_read;
3096
+
+ gboolean first_chunk_header =
3097
+
+ (chunk_index == 0 && len >= 3 &&
3098
+
+ src[0] == 0xff && src[1] == 0x00 && src[2] == 0x06);
3099
+
+ int default_payload_offset;
3100
+
+ gsize payload_offset;
3101
+
+ gsize payload_len;
3102
+
+ gsize remaining;
3103
+
+ gsize to_copy;
3104
+
+
3105
+
+ if (len < CB2000_CHUNK_PAYLOAD_SIZE) {
3106
+
+ fp_warn("Chunk %d too short: got %zu, need >= %d",
3107
+
+ self->chunks_read, len, CB2000_CHUNK_PAYLOAD_SIZE);
3108
+
+ fpi_ssm_mark_failed(transfer->ssm,
3109
+
+ fpi_device_error_new(FP_DEVICE_ERROR_PROTO));
3110
+
+ return;
3111
+
+ }
3112
+
+
3113
+
+ /* Prefer Windows-aligned defaults:
3114
+
+ * - 320-byte framing -> payload at offset 64
3115
+
+ * - first compact chunk with ff 00 06 -> skip 3-byte marker
3116
+
+ * - other compact chunks (including 259-byte tail) -> payload at 0 */
3117
+
+ if (len == CB2000_CHUNK_SIZE) {
3118
+
+ default_payload_offset = CB2000_CHUNK_DEFAULT_PAYLOAD_OFFSET;
3119
+
+ } else if (first_chunk_header) {
3120
+
+ default_payload_offset = 3;
3121
+
+ } else {
3122
+
+ default_payload_offset = 0;
3123
+
+ }
3124
+
+ payload_offset = (gsize) cb2000_get_env_int("CB2000_CHUNK_PAYLOAD_OFFSET",
3125
+
+ default_payload_offset,
3126
+
+ 0,
3127
+
+ (int)len - 1);
3128
+
+ if (payload_offset >= len) {
3129
+
+ fp_warn("Invalid payload window: off=%zu len=%zu chunk=%zu",
3130
+
+ payload_offset, len, len);
3131
+
+ fpi_ssm_mark_failed(transfer->ssm,
3132
+
+ fpi_device_error_new(FP_DEVICE_ERROR_PROTO));
3133
+
+ return;
3134
+
+ }
3135
+
+ payload_len = len - payload_offset;
3136
+
+
3137
+
+ if (self->chunks_read == 0 && len >= 3) {
3138
+
+ fp_dbg("Chunk 0 prefix=%02x %02x %02x payload_off=%zu payload_len=%zu",
3139
+
+ src[0], src[1], src[2], payload_offset, payload_len);
3140
+
+ }
3141
+
+
3142
+
+ remaining = CB2000_IMG_SIZE - self->image_offset;
3143
+
+ to_copy = MIN(payload_len, remaining);
3144
+
+
3145
+
+ if (to_copy > 0) {
3146
+
+ memcpy(self->image_buffer + self->image_offset,
3147
+
+ src + payload_offset,
3148
+
+ to_copy);
3149
+
+ self->image_offset += to_copy;
3150
+
+ }
3151
+
+
3152
+
+ self->chunks_read++;
3153
+
+
3154
+
+ fp_dbg("Chunk %d/%d: read %zu payload_off=%zu payload_len=%zu copied %zu -> total %zu/%d",
3155
+
+ self->chunks_read, CB2000_IMG_CHUNKS,
3156
+
+ transfer->actual_length, payload_offset, payload_len, to_copy,
3157
+
+ self->image_offset, CB2000_IMG_SIZE);
3158
+
+
3159
+
+ if (self->chunks_read >= CB2000_IMG_CHUNKS) {
3160
+
+ fp_dbg("Image complete: %d chunks read", CB2000_IMG_CHUNKS);
3161
+
+ fpi_ssm_mark_completed(transfer->ssm);
3162
+
+ } else {
3163
+
+ fpi_ssm_next_state(transfer->ssm);
3164
+
+ }
3165
+
+}
3166
+
+
3167
+
+/*
3168
+
+ * Write padding between chunk reads. This mirrors Windows behavior and keeps
3169
+
+ * the device in sync.
3170
+
+ */
3171
+
+static void
3172
+
+image_padding_cb(FpiUsbTransfer *transfer,
3173
+
+ FpDevice *dev,
3174
+
+ gpointer user_data,
3175
+
+ GError *error)
3176
+
+{
3177
+
+ if (error) {
3178
+
+ fp_warn("Padding write error: %s", error->message);
3179
+
+ fpi_ssm_mark_failed(transfer->ssm, error);
3180
+
+ return;
3181
+
+ }
3182
+
+
3183
+
+ fpi_ssm_jump_to_state(transfer->ssm, IMG_READ_CHUNK);
3184
+
+}
3185
+
+
3186
+
+/*
3187
+
+ * Image read sub-SSM entry point. Alternates between read and padding writes.
3188
+
+ */
3189
+
+static void
3190
+
+image_read_run_state(FpiSsm *ssm, FpDevice *dev)
3191
+
+{
3192
+
+ switch (fpi_ssm_get_cur_state(ssm)) {
3193
+
+ case IMG_READ_CHUNK:
3194
+
+ cb2000_bulk_read(dev, ssm, CB2000_CHUNK_SIZE, image_chunk_cb, NULL);
3195
+
+ break;
3196
+
+ case IMG_WRITE_PADDING:
3197
+
+ cb2000_bulk_write(dev, ssm, data_padding, CB2000_CHUNK_PAYLOAD_SIZE,
3198
+
+ image_padding_cb, NULL);
3199
+
+ break;
3200
+
+ }
3201
+
+}
3202
+
+
3203
+
+/* ============================================================================
3204
+
+ * NCC CORRELATION MATCHER (V33 real, robust decision)
3205
+
+ * ============================================================================
3206
+
+ * Match strategy:
3207
+
+ * 1) Intensity NCC over small 2D shifts on foreground-only mask.
3208
+
+ * 2) Gradient-magnitude NCC over the same masked support.
3209
+
+ * 3) Conservative decision matrix using top1/top2/mean(top3)/support_count.
3210
+
+ */
3211
+
+
3212
+
+typedef enum {
3213
+
+ CB2000_NCC_DECISION_MATCH = 0,
3214
+
+ CB2000_NCC_DECISION_NO_MATCH,
3215
+
+ CB2000_NCC_DECISION_RETRY,
3216
+
+ CB2000_NCC_DECISION_ERROR,
3217
+
+} Cb2000NccDecision;
3218
+
+
3219
+
+typedef struct {
3220
+
+ gdouble best_intensity;
3221
+
+ gdouble second_intensity;
3222
+
+ gdouble mean_top3_intensity;
3223
+
+ gdouble grad_for_best_intensity;
3224
+
+ guint support_count;
3225
+
+ guint compared_images;
3226
+
+ gdouble enroll_pair_mean_intensity;
3227
+
+ gdouble enroll_pair_min_intensity;
3228
+
+ gdouble enroll_pair_mean_gradient;
3229
+
+ guint enroll_pair_count;
3230
+
+ gdouble adaptive_relax;
3231
+
+} Cb2000NccTelemetry;
3232
+
+
3233
+
+static const char *
3234
+
+cb2000_ncc_decision_label(Cb2000NccDecision decision)
3235
+
+{
3236
+
+ switch (decision) {
3237
+
+ case CB2000_NCC_DECISION_MATCH:
3238
+
+ return "MATCH";
3239
+
+ case CB2000_NCC_DECISION_NO_MATCH:
3240
+
+ return "NO_MATCH";
3241
+
+ case CB2000_NCC_DECISION_RETRY:
3242
+
+ return "RETRY";
3243
+
+ case CB2000_NCC_DECISION_ERROR:
3244
+
+ return "ERROR";
3245
+
+ default:
3246
+
+ return "UNKNOWN";
3247
+
+ }
3248
+
+}
3249
+
+
3250
+
+static gdouble
3251
+
+cb2000_ncc_env_double(const char *name,
3252
+
+ gdouble fallback,
3253
+
+ gdouble min,
3254
+
+ gdouble max)
3255
+
+{
3256
+
+ const char *env = g_getenv(name);
3257
+
+ gdouble val;
3258
+
+
3259
+
+ if (!env || !*env)
3260
+
+ return fallback;
3261
+
+
3262
+
+ val = g_ascii_strtod(env, NULL);
3263
+
+ if (val < min || val > max)
3264
+
+ return fallback;
3265
+
+ return val;
3266
+
+}
3267
+
+
3268
+
+static guint
3269
+
+cb2000_ncc_env_uint(const char *name, guint fallback, guint min, guint max)
3270
+
+{
3271
+
+ const char *env = g_getenv(name);
3272
+
+ char *end = NULL;
3273
+
+ unsigned long val;
3274
+
+
3275
+
+ if (!env || !*env)
3276
+
+ return fallback;
3277
+
+
3278
+
+ val = strtoul(env, &end, 10);
3279
+
+ if (end == env || *end != '\0')
3280
+
+ return fallback;
3281
+
+ if (val < min || val > max)
3282
+
+ return fallback;
3283
+
+ return (guint) val;
3284
+
+}
3285
+
+
3286
+
+static guint
3287
+
+cb2000_build_foreground_mask(const guint8 *img,
3288
+
+ guint8 *mask,
3289
+
+ gint width,
3290
+
+ gint height,
3291
+
+ guint8 threshold)
3292
+
+{
3293
+
+ guint active = 0;
3294
+
+ gint x, y;
3295
+
+
3296
+
+ for (y = 0; y < height; y++) {
3297
+
+ for (x = 0; x < width; x++) {
3298
+
+ gint idx = y * width + x;
3299
+
+ guint8 on = img[idx] >= threshold ? 1 : 0;
3300
+
+ mask[idx] = on;
3301
+
+ active += on;
3302
+
+ }
3303
+
+ }
3304
+
+ return active;
3305
+
+}
3306
+
+
3307
+
+static void
3308
+
+cb2000_compute_gradient_magnitude(const guint8 *img,
3309
+
+ gdouble *grad,
3310
+
+ gint width,
3311
+
+ gint height)
3312
+
+{
3313
+
+ gint x, y;
3314
+
+
3315
+
+ memset(grad, 0, sizeof(*grad) * width * height);
3316
+
+ for (y = 1; y < height - 1; y++) {
3317
+
+ for (x = 1; x < width - 1; x++) {
3318
+
+ gint idx = y * width + x;
3319
+
+ gint gx =
3320
+
+ -img[(y - 1) * width + (x - 1)] + img[(y - 1) * width + (x + 1)] +
3321
+
+ -2 * img[y * width + (x - 1)] + 2 * img[y * width + (x + 1)] +
3322
+
+ -img[(y + 1) * width + (x - 1)] + img[(y + 1) * width + (x + 1)];
3323
+
+ gint gy =
3324
+
+ -img[(y - 1) * width + (x - 1)] - 2 * img[(y - 1) * width + x] - img[(y - 1) * width + (x + 1)] +
3325
+
+ img[(y + 1) * width + (x - 1)] + 2 * img[(y + 1) * width + x] + img[(y + 1) * width + (x + 1)];
3326
+
+ grad[idx] = sqrt((gdouble) gx * gx + (gdouble) gy * gy);
3327
+
+ }
3328
+
+ }
3329
+
+}
3330
+
+
3331
+
+static gdouble
3332
+
+cb2000_ncc_match_u8_masked(const guint8 *a,
3333
+
+ const guint8 *b,
3334
+
+ const guint8 *mask_a,
3335
+
+ const guint8 *mask_b,
3336
+
+ gint width,
3337
+
+ gint height,
3338
+
+ gint max_shift,
3339
+
+ guint min_samples)
3340
+
+{
3341
+
+ gdouble best = -2.0;
3342
+
+ gint dx, dy, x, y;
3343
+
+
3344
+
+ for (dy = -max_shift; dy <= max_shift; dy++) {
3345
+
+ gint y0 = MAX(0, -dy);
3346
+
+ gint y1 = MIN(height, height - dy);
3347
+
+ if (y0 >= y1)
3348
+
+ continue;
3349
+
+
3350
+
+ for (dx = -max_shift; dx <= max_shift; dx++) {
3351
+
+ gint x0 = MAX(0, -dx);
3352
+
+ gint x1 = MIN(width, width - dx);
3353
+
+ guint n = 0;
3354
+
+ gdouble sum_a = 0.0, sum_b = 0.0;
3355
+
+ gdouble mean_a, mean_b;
3356
+
+ gdouble cov = 0.0, var_a = 0.0, var_b = 0.0;
3357
+
+ gdouble score;
3358
+
+
3359
+
+ if (x0 >= x1)
3360
+
+ continue;
3361
+
+
3362
+
+ for (y = y0; y < y1; y++) {
3363
+
+ for (x = x0; x < x1; x++) {
3364
+
+ gint ia = y * width + x;
3365
+
+ gint ib = (y + dy) * width + (x + dx);
3366
+
+ if (!mask_a[ia] || !mask_b[ib])
3367
+
+ continue;
3368
+
+ sum_a += a[ia];
3369
+
+ sum_b += b[ib];
3370
+
+ n++;
3371
+
+ }
3372
+
+ }
3373
+
+
3374
+
+ if (n < min_samples)
3375
+
+ continue;
3376
+
+
3377
+
+ mean_a = sum_a / n;
3378
+
+ mean_b = sum_b / n;
3379
+
+
3380
+
+ for (y = y0; y < y1; y++) {
3381
+
+ for (x = x0; x < x1; x++) {
3382
+
+ gint ia = y * width + x;
3383
+
+ gint ib = (y + dy) * width + (x + dx);
3384
+
+ gdouble da, db;
3385
+
+ if (!mask_a[ia] || !mask_b[ib])
3386
+
+ continue;
3387
+
+ da = a[ia] - mean_a;
3388
+
+ db = b[ib] - mean_b;
3389
+
+ cov += da * db;
3390
+
+ var_a += da * da;
3391
+
+ var_b += db * db;
3392
+
+ }
3393
+
+ }
3394
+
+
3395
+
+ score = (var_a < 1.0 || var_b < 1.0) ? 0.0 : cov / sqrt(var_a * var_b);
3396
+
+ if (score > best)
3397
+
+ best = score;
3398
+
+ }
3399
+
+ }
3400
+
+
3401
+
+ if (best < -1.0)
3402
+
+ return 0.0;
3403
+
+ return best;
3404
+
+}
3405
+
+
3406
+
+static gdouble
3407
+
+cb2000_ncc_match_f64_masked(const gdouble *a,
3408
+
+ const gdouble *b,
3409
+
+ const guint8 *mask_a,
3410
+
+ const guint8 *mask_b,
3411
+
+ gint width,
3412
+
+ gint height,
3413
+
+ gint max_shift,
3414
+
+ guint min_samples)
3415
+
+{
3416
+
+ gdouble best = -2.0;
3417
+
+ gint dx, dy, x, y;
3418
+
+
3419
+
+ for (dy = -max_shift; dy <= max_shift; dy++) {
3420
+
+ gint y0 = MAX(0, -dy);
3421
+
+ gint y1 = MIN(height, height - dy);
3422
+
+ if (y0 >= y1)
3423
+
+ continue;
3424
+
+
3425
+
+ for (dx = -max_shift; dx <= max_shift; dx++) {
3426
+
+ gint x0 = MAX(0, -dx);
3427
+
+ gint x1 = MIN(width, width - dx);
3428
+
+ guint n = 0;
3429
+
+ gdouble sum_a = 0.0, sum_b = 0.0;
3430
+
+ gdouble mean_a, mean_b;
3431
+
+ gdouble cov = 0.0, var_a = 0.0, var_b = 0.0;
3432
+
+ gdouble score;
3433
+
+
3434
+
+ if (x0 >= x1)
3435
+
+ continue;
3436
+
+
3437
+
+ for (y = y0; y < y1; y++) {
3438
+
+ for (x = x0; x < x1; x++) {
3439
+
+ gint ia = y * width + x;
3440
+
+ gint ib = (y + dy) * width + (x + dx);
3441
+
+ if (!mask_a[ia] || !mask_b[ib])
3442
+
+ continue;
3443
+
+ sum_a += a[ia];
3444
+
+ sum_b += b[ib];
3445
+
+ n++;
3446
+
+ }
3447
+
+ }
3448
+
+
3449
+
+ if (n < min_samples)
3450
+
+ continue;
3451
+
+
3452
+
+ mean_a = sum_a / n;
3453
+
+ mean_b = sum_b / n;
3454
+
+
3455
+
+ for (y = y0; y < y1; y++) {
3456
+
+ for (x = x0; x < x1; x++) {
3457
+
+ gint ia = y * width + x;
3458
+
+ gint ib = (y + dy) * width + (x + dx);
3459
+
+ gdouble da, db;
3460
+
+ if (!mask_a[ia] || !mask_b[ib])
3461
+
+ continue;
3462
+
+ da = a[ia] - mean_a;
3463
+
+ db = b[ib] - mean_b;
3464
+
+ cov += da * db;
3465
+
+ var_a += da * da;
3466
+
+ var_b += db * db;
3467
+
+ }
3468
+
+ }
3469
+
+
3470
+
+ score = (var_a < 1.0 || var_b < 1.0) ? 0.0 : cov / sqrt(var_a * var_b);
3471
+
+ if (score > best)
3472
+
+ best = score;
3473
+
+ }
3474
+
+ }
3475
+
+
3476
+
+ if (best < -1.0)
3477
+
+ return 0.0;
3478
+
+ return best;
3479
+
+}
3480
+
+
3481
+
+static gdouble
3482
+
+cb2000_ncc_compute_adaptive_relax(const Cb2000NccTelemetry *tel)
3483
+
+{
3484
+
+ guint adaptive_enabled = cb2000_ncc_env_uint("CB2000_NCC_ADAPTIVE",
3485
+
+ CB2000_NCC_ADAPTIVE_ENABLED_DEFAULT,
3486
+
+ 0, 1);
3487
+
+ gdouble max_relax = cb2000_ncc_env_double("CB2000_NCC_ADAPTIVE_MAX_RELAX",
3488
+
+ CB2000_NCC_ADAPTIVE_MAX_RELAX_DEFAULT,
3489
+
+ 0.0, 0.20);
3490
+
+ gdouble target_mean = cb2000_ncc_env_double("CB2000_NCC_ADAPTIVE_TARGET_MEAN",
3491
+
+ CB2000_NCC_ADAPTIVE_TARGET_MEAN_DEFAULT,
3492
+
+ 0.0, 1.0);
3493
+
+ gdouble target_min = cb2000_ncc_env_double("CB2000_NCC_ADAPTIVE_TARGET_MIN",
3494
+
+ CB2000_NCC_ADAPTIVE_TARGET_MIN_DEFAULT,
3495
+
+ 0.0, 1.0);
3496
+
+ gdouble deficit_mean;
3497
+
+ gdouble deficit_min;
3498
+
+ gdouble relax;
3499
+
+
3500
+
+ if (!adaptive_enabled || tel->enroll_pair_count == 0)
3501
+
+ return 0.0;
3502
+
+
3503
+
+ deficit_mean = MAX(0.0, target_mean - tel->enroll_pair_mean_intensity);
3504
+
+ deficit_min = MAX(0.0, target_min - tel->enroll_pair_min_intensity);
3505
+
+
3506
+
+ /* Weighted deficits: broad cohesion (mean) + worst-case spread (min). */
3507
+
+ relax = deficit_mean * 0.60 + deficit_min * 0.40;
3508
+
+ if (relax > max_relax)
3509
+
+ relax = max_relax;
3510
+
+ if (relax < 0.0)
3511
+
+ relax = 0.0;
3512
+
+ return relax;
3513
+
+}
3514
+
+
3515
+
+static void
3516
+
+cb2000_ncc_compute_enroll_cohesion(const guint8 *images_data,
3517
+
+ gint n_images,
3518
+
+ guint8 mask_threshold,
3519
+
+ guint min_samples,
3520
+
+ gint max_shift,
3521
+
+ Cb2000NccTelemetry *tel)
3522
+
+{
3523
+
+ guint8 masks[CB2000_NR_ENROLL_STAGES][CB2000_IMG_SIZE];
3524
+
+ gdouble grads[CB2000_NR_ENROLL_STAGES][CB2000_IMG_SIZE];
3525
+
+ const guint8 *images[CB2000_NR_ENROLL_STAGES];
3526
+
+ gdouble sum_int = 0.0;
3527
+
+ gdouble sum_grad = 0.0;
3528
+
+ gdouble min_int = 1.0;
3529
+
+ guint pairs = 0;
3530
+
+ gint i, j;
3531
+
+
3532
+
+ tel->enroll_pair_mean_intensity = 0.0;
3533
+
+ tel->enroll_pair_min_intensity = 0.0;
3534
+
+ tel->enroll_pair_mean_gradient = 0.0;
3535
+
+ tel->enroll_pair_count = 0;
3536
+
+
3537
+
+ if (n_images < 2)
3538
+
+ return;
3539
+
+
3540
+
+ n_images = MIN(n_images, CB2000_NR_ENROLL_STAGES);
3541
+
+
3542
+
+ for (i = 0; i < n_images; i++) {
3543
+
+ images[i] = images_data + (i * CB2000_IMG_SIZE);
3544
+
+ cb2000_build_foreground_mask(images[i], masks[i],
3545
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
3546
+
+ mask_threshold);
3547
+
+ cb2000_compute_gradient_magnitude(images[i], grads[i],
3548
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
3549
+
+ }
3550
+
+
3551
+
+ for (i = 0; i < n_images; i++) {
3552
+
+ for (j = i + 1; j < n_images; j++) {
3553
+
+ gdouble int_pair = cb2000_ncc_match_u8_masked(images[i], images[j],
3554
+
+ masks[i], masks[j],
3555
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
3556
+
+ max_shift, min_samples);
3557
+
+ gdouble grad_pair = cb2000_ncc_match_f64_masked(grads[i], grads[j],
3558
+
+ masks[i], masks[j],
3559
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
3560
+
+ max_shift, min_samples);
3561
+
+ sum_int += int_pair;
3562
+
+ sum_grad += grad_pair;
3563
+
+ min_int = MIN(min_int, int_pair);
3564
+
+ pairs++;
3565
+
+ fp_dbg("[ NCC ] cohesion pair=%d-%d int=%.4f grad=%.4f",
3566
+
+ i, j, int_pair, grad_pair);
3567
+
+ }
3568
+
+ }
3569
+
+
3570
+
+ if (pairs == 0)
3571
+
+ return;
3572
+
+
3573
+
+ tel->enroll_pair_count = pairs;
3574
+
+ tel->enroll_pair_mean_intensity = sum_int / pairs;
3575
+
+ tel->enroll_pair_min_intensity = min_int;
3576
+
+ tel->enroll_pair_mean_gradient = sum_grad / pairs;
3577
+
+}
3578
+
+
3579
+
+static Cb2000NccDecision
3580
+
+cb2000_ncc_classify(const Cb2000NccTelemetry *tel)
3581
+
+{
3582
+
+ gdouble match_top1 = cb2000_ncc_env_double("CB2000_NCC_MATCH_TOP1",
3583
+
+ CB2000_NCC_MATCH_TOP1_DEFAULT,
3584
+
+ 0.0, 1.0);
3585
+
+ gdouble match_top2 = cb2000_ncc_env_double("CB2000_NCC_MATCH_TOP2",
3586
+
+ CB2000_NCC_MATCH_TOP2_DEFAULT,
3587
+
+ 0.0, 1.0);
3588
+
+ gdouble match_mean3 = cb2000_ncc_env_double("CB2000_NCC_MATCH_MEAN3",
3589
+
+ CB2000_NCC_MATCH_MEAN3_DEFAULT,
3590
+
+ 0.0, 1.0);
3591
+
+ gdouble match_grad1 = cb2000_ncc_env_double("CB2000_NCC_MATCH_GRAD1",
3592
+
+ CB2000_NCC_MATCH_GRAD1_DEFAULT,
3593
+
+ 0.0, 1.0);
3594
+
+ guint support_min = cb2000_ncc_env_uint("CB2000_NCC_SUPPORT_MIN",
3595
+
+ CB2000_NCC_SUPPORT_MIN_DEFAULT,
3596
+
+ 1, CB2000_NR_ENROLL_STAGES);
3597
+
+ gdouble medium_top1 = cb2000_ncc_env_double("CB2000_NCC_MEDIUM_TOP1",
3598
+
+ CB2000_NCC_MEDIUM_TOP1_DEFAULT,
3599
+
+ 0.0, 1.0);
3600
+
+ gdouble medium_top2 = cb2000_ncc_env_double("CB2000_NCC_MEDIUM_TOP2",
3601
+
+ CB2000_NCC_MEDIUM_TOP2_DEFAULT,
3602
+
+ 0.0, 1.0);
3603
+
+ gdouble medium_mean3 = cb2000_ncc_env_double("CB2000_NCC_MEDIUM_MEAN3",
3604
+
+ CB2000_NCC_MEDIUM_MEAN3_DEFAULT,
3605
+
+ 0.0, 1.0);
3606
+
+ gdouble medium_grad1 = cb2000_ncc_env_double("CB2000_NCC_MEDIUM_GRAD1",
3607
+
+ CB2000_NCC_MEDIUM_GRAD1_DEFAULT,
3608
+
+ 0.0, 1.0);
3609
+
+ guint medium_support_min = cb2000_ncc_env_uint("CB2000_NCC_MEDIUM_SUPPORT_MIN",
3610
+
+ CB2000_NCC_MEDIUM_SUPPORT_MIN_DEFAULT,
3611
+
+ 1, CB2000_NR_ENROLL_STAGES);
3612
+
+ gdouble dominant_top1 = cb2000_ncc_env_double("CB2000_NCC_DOMINANT_TOP1",
3613
+
+ CB2000_NCC_DOMINANT_TOP1_DEFAULT,
3614
+
+ 0.0, 1.0);
3615
+
+ gdouble dominant_top2 = cb2000_ncc_env_double("CB2000_NCC_DOMINANT_TOP2",
3616
+
+ CB2000_NCC_DOMINANT_TOP2_DEFAULT,
3617
+
+ 0.0, 1.0);
3618
+
+ gdouble dominant_mean3 = cb2000_ncc_env_double("CB2000_NCC_DOMINANT_MEAN3",
3619
+
+ CB2000_NCC_DOMINANT_MEAN3_DEFAULT,
3620
+
+ 0.0, 1.0);
3621
+
+ gdouble dominant_grad1 = cb2000_ncc_env_double("CB2000_NCC_DOMINANT_GRAD1",
3622
+
+ CB2000_NCC_DOMINANT_GRAD1_DEFAULT,
3623
+
+ 0.0, 1.0);
3624
+
+ guint dominant_support_min = cb2000_ncc_env_uint("CB2000_NCC_DOMINANT_SUPPORT_MIN",
3625
+
+ CB2000_NCC_DOMINANT_SUPPORT_MIN_DEFAULT,
3626
+
+ 1, CB2000_NR_ENROLL_STAGES);
3627
+
+ gdouble consistent_top1 = cb2000_ncc_env_double("CB2000_NCC_CONSISTENT_TOP1",
3628
+
+ CB2000_NCC_CONSISTENT_TOP1_DEFAULT,
3629
+
+ 0.0, 1.0);
3630
+
+ gdouble consistent_mean3 = cb2000_ncc_env_double("CB2000_NCC_CONSISTENT_MEAN3",
3631
+
+ CB2000_NCC_CONSISTENT_MEAN3_DEFAULT,
3632
+
+ 0.0, 1.0);
3633
+
+ gdouble consistent_grad1 = cb2000_ncc_env_double("CB2000_NCC_CONSISTENT_GRAD1",
3634
+
+ CB2000_NCC_CONSISTENT_GRAD1_DEFAULT,
3635
+
+ 0.0, 1.0);
3636
+
+ guint consistent_support_min = cb2000_ncc_env_uint("CB2000_NCC_CONSISTENT_SUPPORT_MIN",
3637
+
+ CB2000_NCC_CONSISTENT_SUPPORT_MIN_DEFAULT,
3638
+
+ 1, CB2000_NR_ENROLL_STAGES);
3639
+
+ gdouble single_top1 = cb2000_ncc_env_double("CB2000_NCC_SINGLE_TOP1",
3640
+
+ CB2000_NCC_SINGLE_TOP1_DEFAULT,
3641
+
+ 0.0, 1.0);
3642
+
+ gdouble single_top2 = cb2000_ncc_env_double("CB2000_NCC_SINGLE_TOP2",
3643
+
+ CB2000_NCC_SINGLE_TOP2_DEFAULT,
3644
+
+ 0.0, 1.0);
3645
+
+ gdouble single_mean3 = cb2000_ncc_env_double("CB2000_NCC_SINGLE_MEAN3",
3646
+
+ CB2000_NCC_SINGLE_MEAN3_DEFAULT,
3647
+
+ 0.0, 1.0);
3648
+
+ gdouble single_grad1 = cb2000_ncc_env_double("CB2000_NCC_SINGLE_GRAD1",
3649
+
+ CB2000_NCC_SINGLE_GRAD1_DEFAULT,
3650
+
+ 0.0, 1.0);
3651
+
+ guint single_support_min = cb2000_ncc_env_uint("CB2000_NCC_SINGLE_SUPPORT_MIN",
3652
+
+ CB2000_NCC_SINGLE_SUPPORT_MIN_DEFAULT,
3653
+
+ 1, CB2000_NR_ENROLL_STAGES);
3654
+
+ gdouble nomatch_top1 = cb2000_ncc_env_double("CB2000_NCC_NOMATCH_TOP1",
3655
+
+ CB2000_NCC_NOMATCH_TOP1_DEFAULT,
3656
+
+ 0.0, 1.0);
3657
+
+ gdouble clear_nomatch_top1 = cb2000_ncc_env_double("CB2000_NCC_CLEAR_NOMATCH_TOP1",
3658
+
+ CB2000_NCC_CLEAR_NOMATCH_TOP1_DEFAULT,
3659
+
+ 0.0, 1.0);
3660
+
+ gdouble clear_nomatch_mean3 = cb2000_ncc_env_double("CB2000_NCC_CLEAR_NOMATCH_MEAN3",
3661
+
+ CB2000_NCC_CLEAR_NOMATCH_MEAN3_DEFAULT,
3662
+
+ 0.0, 1.0);
3663
+
+ guint adaptive_relax_support = cb2000_ncc_env_uint("CB2000_NCC_ADAPTIVE_RELAX_SUPPORT",
3664
+
+ CB2000_NCC_ADAPTIVE_RELAX_SUPPORT_DEFAULT,
3665
+
+ 0, 1);
3666
+
+ gdouble relax = cb2000_ncc_compute_adaptive_relax(tel);
3667
+
+
3668
+
+ if (relax > 0.0) {
3669
+
+ match_top1 = MAX(0.0, match_top1 - relax);
3670
+
+ match_top2 = MAX(0.0, match_top2 - (relax * 0.75));
3671
+
+ match_mean3 = MAX(0.0, match_mean3 - (relax * 0.75));
3672
+
+ match_grad1 = MAX(0.0, match_grad1 - (relax * 0.50));
3673
+
+
3674
+
+ medium_top1 = MAX(0.0, medium_top1 - relax);
3675
+
+ medium_top2 = MAX(0.0, medium_top2 - (relax * 0.80));
3676
+
+ medium_mean3 = MAX(0.0, medium_mean3 - (relax * 0.80));
3677
+
+ medium_grad1 = MAX(0.0, medium_grad1 - (relax * 0.50));
3678
+
+
3679
+
+ dominant_top1 = MAX(0.0, dominant_top1 - (relax * 0.40));
3680
+
+ dominant_top2 = MAX(0.0, dominant_top2 - (relax * 0.25));
3681
+
+ dominant_mean3 = MAX(0.0, dominant_mean3 - (relax * 0.50));
3682
+
+ dominant_grad1 = MAX(0.0, dominant_grad1 - (relax * 0.40));
3683
+
+
3684
+
+ consistent_top1 = MAX(0.0, consistent_top1 - (relax * 0.60));
3685
+
+ consistent_mean3 = MAX(0.0, consistent_mean3 - (relax * 0.50));
3686
+
+ consistent_grad1 = MAX(0.0, consistent_grad1 - (relax * 0.40));
3687
+
+ single_top1 = MAX(0.0, single_top1 - (relax * 0.20));
3688
+
+ single_top2 = MAX(0.0, single_top2 - (relax * 0.10));
3689
+
+ single_mean3 = MAX(0.0, single_mean3 - (relax * 0.20));
3690
+
+ single_grad1 = MAX(0.0, single_grad1 - (relax * 0.20));
3691
+
+
3692
+
+ if (adaptive_relax_support) {
3693
+
+ if (support_min > 1 && relax >= CB2000_NCC_ADAPTIVE_SUPPORT_RELAX_AT)
3694
+
+ support_min--;
3695
+
+ if (medium_support_min > 1 && relax >= CB2000_NCC_ADAPTIVE_SUPPORT_RELAX_AT)
3696
+
+ medium_support_min--;
3697
+
+ if (consistent_support_min > 1 && relax >= CB2000_NCC_ADAPTIVE_SUPPORT_RELAX_AT)
3698
+
+ consistent_support_min--;
3699
+
+ if (single_support_min > 1 && relax >= CB2000_NCC_ADAPTIVE_SUPPORT_RELAX_AT)
3700
+
+ single_support_min--;
3701
+
+ }
3702
+
+ }
3703
+
+
3704
+
+ fp_dbg("[ NCC ] classify thresholds: strong(top1>=%.3f top2>=%.3f mean3>=%.3f grad1>=%.3f support>=%u) "
3705
+
+ "medium(top1>=%.3f top2>=%.3f mean3>=%.3f grad1>=%.3f support>=%u) "
3706
+
+ "dominant(top1>=%.3f top2>=%.3f mean3>=%.3f grad1>=%.3f support>=%u) "
3707
+
+ "consistent(top1>=%.3f mean3>=%.3f grad1>=%.3f support>=%u) "
3708
+
+ "single(top1>=%.3f top2>=%.3f mean3>=%.3f grad1>=%.3f support>=%u) "
3709
+
+ "clear_nomatch(support==0 && top1<%.3f && mean3<%.3f) "
3710
+
+ "nomatch(top1<%.3f) "
3711
+
+ "adaptive(relax=%.3f relax_support=%u cohesion_mean=%.3f cohesion_min=%.3f pairs=%u)",
3712
+
+ match_top1, match_top2, match_mean3, match_grad1, support_min,
3713
+
+ medium_top1, medium_top2, medium_mean3, medium_grad1, medium_support_min,
3714
+
+ dominant_top1, dominant_top2, dominant_mean3, dominant_grad1, dominant_support_min,
3715
+
+ consistent_top1, consistent_mean3, consistent_grad1, consistent_support_min,
3716
+
+ single_top1, single_top2, single_mean3, single_grad1, single_support_min,
3717
+
+ clear_nomatch_top1, clear_nomatch_mean3,
3718
+
+ nomatch_top1,
3719
+
+ relax,
3720
+
+ adaptive_relax_support,
3721
+
+ tel->enroll_pair_mean_intensity,
3722
+
+ tel->enroll_pair_min_intensity,
3723
+
+ tel->enroll_pair_count);
3724
+
+
3725
+
+ if (tel->compared_images == 0)
3726
+
+ return CB2000_NCC_DECISION_ERROR;
3727
+
+
3728
+
+ if (tel->support_count >= support_min &&
3729
+
+ tel->best_intensity >= match_top1 &&
3730
+
+ tel->second_intensity >= match_top2 &&
3731
+
+ tel->mean_top3_intensity >= match_mean3 &&
3732
+
+ tel->grad_for_best_intensity >= match_grad1)
3733
+
+ return CB2000_NCC_DECISION_MATCH;
3734
+
+
3735
+
+ if (tel->support_count >= medium_support_min &&
3736
+
+ tel->best_intensity >= medium_top1 &&
3737
+
+ tel->second_intensity >= medium_top2 &&
3738
+
+ tel->mean_top3_intensity >= medium_mean3 &&
3739
+
+ tel->grad_for_best_intensity >= medium_grad1)
3740
+
+ return CB2000_NCC_DECISION_MATCH;
3741
+
+
3742
+
+ if (tel->support_count >= dominant_support_min &&
3743
+
+ tel->best_intensity >= dominant_top1 &&
3744
+
+ tel->second_intensity >= dominant_top2 &&
3745
+
+ tel->mean_top3_intensity >= dominant_mean3 &&
3746
+
+ tel->grad_for_best_intensity >= dominant_grad1)
3747
+
+ return CB2000_NCC_DECISION_MATCH;
3748
+
+
3749
+
+ if (tel->support_count >= consistent_support_min &&
3750
+
+ tel->best_intensity >= consistent_top1 &&
3751
+
+ tel->mean_top3_intensity >= consistent_mean3 &&
3752
+
+ tel->grad_for_best_intensity >= consistent_grad1)
3753
+
+ return CB2000_NCC_DECISION_MATCH;
3754
+
+
3755
+
+ if (tel->support_count >= single_support_min &&
3756
+
+ tel->best_intensity >= single_top1 &&
3757
+
+ tel->second_intensity >= single_top2 &&
3758
+
+ tel->mean_top3_intensity >= single_mean3 &&
3759
+
+ tel->grad_for_best_intensity >= single_grad1)
3760
+
+ return CB2000_NCC_DECISION_MATCH;
3761
+
+
3762
+
+ if (tel->support_count == 0 &&
3763
+
+ tel->best_intensity < clear_nomatch_top1 &&
3764
+
+ tel->mean_top3_intensity < clear_nomatch_mean3)
3765
+
+ return CB2000_NCC_DECISION_NO_MATCH;
3766
+
+
3767
+
+ if (tel->best_intensity < nomatch_top1)
3768
+
+ return CB2000_NCC_DECISION_NO_MATCH;
3769
+
+
3770
+
+ return CB2000_NCC_DECISION_RETRY;
3771
+
+}
3772
+
+
3773
+
+/* ============================================================================
3774
+
+ * GVARIANT PRINT STORAGE (V33)
3775
+
+ * ============================================================================
3776
+
+ * Enrollment stores preprocessed 80x64 images in GVariant format.
3777
+
+ * Format: (uqqay) = (version, width, height, concatenated_images)
3778
+
+ */
3779
+
+
3780
+
+/**
3781
+
+ * pack_enrollment_data - Store enrollment images into a print
3782
+
+ * @self: Device instance with enrollment images
3783
+
+ * @print: FpPrint to store data into
3784
+
+ *
3785
+
+ * Packs all enrollment images into a GVariant and sets it on the print.
3786
+
+ */
3787
+
+static void
3788
+
+pack_enrollment_data(FpiDeviceCanvasbioCb2000 *self, FpPrint *print)
3789
+
+{
3790
+
+ gsize total_size = CB2000_NR_ENROLL_STAGES * CB2000_IMG_SIZE;
3791
+
+ guint8 *all_images = g_malloc(total_size);
3792
+
+ gint i;
3793
+
+ GVariant *images_var;
3794
+
+ GVariant *data;
3795
+
+
3796
+
+ for (i = 0; i < CB2000_NR_ENROLL_STAGES; i++)
3797
+
+ memcpy(all_images + i * CB2000_IMG_SIZE,
3798
+
+ self->enroll_images[i], CB2000_IMG_SIZE);
3799
+
+
3800
+
+ images_var = g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
3801
+
+ all_images, total_size, 1);
3802
+
+
3803
+
+ data = g_variant_new(CB2000_PRINT_FORMAT,
3804
+
+ (guint32) 1,
3805
+
+ (guint16) CB2000_IMG_WIDTH,
3806
+
+ (guint16) CB2000_IMG_HEIGHT,
3807
+
+ images_var);
3808
+
+
3809
+
+ fpi_print_set_type(print, FPI_PRINT_RAW);
3810
+
+ g_object_set(print, "fpi-data", data, NULL);
3811
+
+
3812
+
+ g_free(all_images);
3813
+
+
3814
+
+ fp_info("Packed %d enrollment images (%zu bytes total)",
3815
+
+ CB2000_NR_ENROLL_STAGES, total_size);
3816
+
+}
3817
+
+
3818
+
+/**
3819
+
+ * unpack_and_match - Unpack enrolled images and run robust NCC telemetry
3820
+
+ * @print: Enrolled FpPrint containing stored images
3821
+
+ * @captured: Captured image to match against (CB2000_IMG_SIZE bytes)
3822
+
+ * @tel: Output telemetry for decision matrix
3823
+
+ *
3824
+
+ * Returns TRUE if unpack succeeded, FALSE on format error.
3825
+
+ */
3826
+
+static gboolean
3827
+
+unpack_and_match(FpPrint *print, const guint8 *captured, Cb2000NccTelemetry *tel)
3828
+
+{
3829
+
+ g_autoptr(GVariant) print_data = NULL;
3830
+
+ g_autoptr(GVariant) images_var = NULL;
3831
+
+ gdouble captured_grad[CB2000_IMG_SIZE];
3832
+
+ guint8 captured_mask[CB2000_IMG_SIZE];
3833
+
+ gdouble top_scores[CB2000_NR_ENROLL_STAGES] = {0};
3834
+
+ guint32 version;
3835
+
+ guint16 width, height;
3836
+
+ const guint8 *images_data;
3837
+
+ gsize images_len;
3838
+
+ guint mask_threshold;
3839
+
+ guint min_samples;
3840
+
+ guint support_min;
3841
+
+ gint max_shift;
3842
+
+ gdouble support_int;
3843
+
+ gdouble support_grad;
3844
+
+ gdouble support_int_effective;
3845
+
+ gdouble support_grad_effective;
3846
+
+ gint n_images;
3847
+
+ gint i;
3848
+
+ guint top_n;
3849
+
+
3850
+
+ g_object_get(print, "fpi-data", &print_data, NULL);
3851
+
+ if (!print_data) {
3852
+
+ fp_warn("No print data found");
3853
+
+ return FALSE;
3854
+
+ }
3855
+
+
3856
+
+ if (!g_variant_check_format_string(print_data, CB2000_PRINT_FORMAT, FALSE)) {
3857
+
+ fp_warn("Invalid print data format");
3858
+
+ return FALSE;
3859
+
+ }
3860
+
+
3861
+
+ g_variant_get(print_data, CB2000_PRINT_FORMAT,
3862
+
+ &version, &width, &height, &images_var);
3863
+
+
3864
+
+ if (version != 1 || width != CB2000_IMG_WIDTH || height != CB2000_IMG_HEIGHT) {
3865
+
+ fp_warn("Print data version/size mismatch: v=%u w=%u h=%u",
3866
+
+ version, width, height);
3867
+
+ return FALSE;
3868
+
+ }
3869
+
+
3870
+
+ images_data = g_variant_get_fixed_array(images_var, &images_len, 1);
3871
+
+ n_images = images_len / CB2000_IMG_SIZE;
3872
+
+
3873
+
+ if (n_images < 1 || images_len % CB2000_IMG_SIZE != 0) {
3874
+
+ fp_warn("Invalid image data length: %zu", images_len);
3875
+
+ return FALSE;
3876
+
+ }
3877
+
+
3878
+
+ memset(tel, 0, sizeof(*tel));
3879
+
+ tel->best_intensity = -1.0;
3880
+
+ tel->second_intensity = -1.0;
3881
+
+ tel->mean_top3_intensity = -1.0;
3882
+
+ tel->grad_for_best_intensity = 0.0;
3883
+
+
3884
+
+ mask_threshold = cb2000_ncc_env_uint("CB2000_NCC_MASK_THRESH",
3885
+
+ CB2000_NCC_MASK_THRESHOLD_DEFAULT,
3886
+
+ 1, 254);
3887
+
+ min_samples = cb2000_ncc_env_uint("CB2000_NCC_MIN_SAMPLES",
3888
+
+ CB2000_NCC_MIN_SAMPLES_DEFAULT,
3889
+
+ 64, CB2000_IMG_SIZE);
3890
+
+ support_min = cb2000_ncc_env_uint("CB2000_NCC_SUPPORT_MIN",
3891
+
+ CB2000_NCC_SUPPORT_MIN_DEFAULT,
3892
+
+ 1, CB2000_NR_ENROLL_STAGES);
3893
+
+ support_int = cb2000_ncc_env_double("CB2000_NCC_SUPPORT_INT",
3894
+
+ CB2000_NCC_SUPPORT_INT_DEFAULT,
3895
+
+ 0.0, 1.0);
3896
+
+ support_grad = cb2000_ncc_env_double("CB2000_NCC_SUPPORT_GRAD",
3897
+
+ CB2000_NCC_SUPPORT_GRAD_DEFAULT,
3898
+
+ 0.0, 1.0);
3899
+
+ max_shift = (gint) cb2000_ncc_env_uint("CB2000_NCC_MAX_SHIFT",
3900
+
+ CB2000_NCC_MAX_SHIFT_DEFAULT,
3901
+
+ 0, 8);
3902
+
+
3903
+
+ cb2000_ncc_compute_enroll_cohesion(images_data, n_images,
3904
+
+ (guint8) mask_threshold,
3905
+
+ min_samples,
3906
+
+ max_shift,
3907
+
+ tel);
3908
+
+ tel->adaptive_relax = cb2000_ncc_compute_adaptive_relax(tel);
3909
+
+ support_int_effective = MAX(0.0, support_int - (tel->adaptive_relax * 0.50));
3910
+
+ support_grad_effective = MAX(0.0, support_grad - (tel->adaptive_relax * 0.35));
3911
+
+
3912
+
+ fp_info("[ NCC ] enroll cohesion: pairs=%u mean_int=%.4f min_int=%.4f mean_grad=%.4f relax=%.4f",
3913
+
+ tel->enroll_pair_count,
3914
+
+ tel->enroll_pair_mean_intensity,
3915
+
+ tel->enroll_pair_min_intensity,
3916
+
+ tel->enroll_pair_mean_gradient,
3917
+
+ tel->adaptive_relax);
3918
+
+
3919
+
+ cb2000_build_foreground_mask(captured, captured_mask,
3920
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
3921
+
+ (guint8) mask_threshold);
3922
+
+ cb2000_compute_gradient_magnitude(captured, captured_grad,
3923
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
3924
+
+
3925
+
+ for (i = 0; i < n_images; i++) {
3926
+
+ const guint8 *enrolled = images_data + i * CB2000_IMG_SIZE;
3927
+
+ gdouble enrolled_grad[CB2000_IMG_SIZE];
3928
+
+ guint8 enrolled_mask[CB2000_IMG_SIZE];
3929
+
+ gdouble int_score;
3930
+
+ gdouble grad_score;
3931
+
+
3932
+
+ cb2000_build_foreground_mask(enrolled, enrolled_mask,
3933
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
3934
+
+ (guint8) mask_threshold);
3935
+
+ cb2000_compute_gradient_magnitude(enrolled, enrolled_grad,
3936
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
3937
+
+
3938
+
+ int_score = cb2000_ncc_match_u8_masked(captured, enrolled,
3939
+
+ captured_mask, enrolled_mask,
3940
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
3941
+
+ max_shift, min_samples);
3942
+
+ grad_score = cb2000_ncc_match_f64_masked(captured_grad, enrolled_grad,
3943
+
+ captured_mask, enrolled_mask,
3944
+
+ CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
3945
+
+ max_shift, min_samples);
3946
+
+
3947
+
+ top_scores[i] = int_score;
3948
+
+ tel->compared_images++;
3949
+
+
3950
+
+ if (int_score > tel->best_intensity) {
3951
+
+ tel->second_intensity = tel->best_intensity;
3952
+
+ tel->best_intensity = int_score;
3953
+
+ tel->grad_for_best_intensity = grad_score;
3954
+
+ } else if (int_score > tel->second_intensity) {
3955
+
+ tel->second_intensity = int_score;
3956
+
+ }
3957
+
+
3958
+
+ if (int_score >= support_int_effective && grad_score >= support_grad_effective)
3959
+
+ tel->support_count++;
3960
+
+
3961
+
+ fp_dbg("[ NCC ] gallery=%d int=%.4f grad=%.4f", i, int_score, grad_score);
3962
+
+ }
3963
+
+
3964
+
+ top_n = MIN((guint) n_images, (guint) 3);
3965
+
+ for (i = 0; i < n_images; i++) {
3966
+
+ gint j;
3967
+
+ for (j = i + 1; j < n_images; j++) {
3968
+
+ if (top_scores[j] > top_scores[i]) {
3969
+
+ gdouble tmp = top_scores[i];
3970
+
+ top_scores[i] = top_scores[j];
3971
+
+ top_scores[j] = tmp;
3972
+
+ }
3973
+
+ }
3974
+
+ }
3975
+
+ if (top_n > 0) {
3976
+
+ gdouble sum = 0.0;
3977
+
+ for (i = 0; i < (gint) top_n; i++)
3978
+
+ sum += top_scores[i];
3979
+
+ tel->mean_top3_intensity = sum / top_n;
3980
+
+ } else {
3981
+
+ tel->mean_top3_intensity = 0.0;
3982
+
+ }
3983
+
+
3984
+
+ if (tel->second_intensity < 0.0)
3985
+
+ tel->second_intensity = 0.0;
3986
+
+ if (tel->best_intensity < 0.0)
3987
+
+ tel->best_intensity = 0.0;
3988
+
+
3989
+
+ fp_info("[ NCC ] top1=%.4f top2=%.4f mean3=%.4f grad1=%.4f support=%u/%u "
3990
+
+ "mask_thresh=%u min_samples=%u max_shift=%d support_min=%u "
3991
+
+ "support_int=%.3f(%.3f) support_grad=%.3f(%.3f) adapt=%.3f",
3992
+
+ tel->best_intensity,
3993
+
+ tel->second_intensity,
3994
+
+ tel->mean_top3_intensity,
3995
+
+ tel->grad_for_best_intensity,
3996
+
+ tel->support_count,
3997
+
+ tel->compared_images,
3998
+
+ mask_threshold,
3999
+
+ min_samples,
4000
+
+ max_shift,
4001
+
+ support_min,
4002
+
+ support_int,
4003
+
+ support_int_effective,
4004
+
+ support_grad,
4005
+
+ support_grad_effective,
4006
+
+ tel->adaptive_relax);
4007
+
+
4008
+
+ return TRUE;
4009
+
+}
4010
+
+
4011
+
+/* ============================================================================
4012
+
+ * MASTER CYCLE SSM
4013
+
+ * ============================================================================
4014
+
+ *
4015
+
+ * Complete capture cycle matching Windows 1:1:
4016
+
+ * HARD_RESET -> INIT_CONFIG -> SETTLE_DELAY -> WAIT_FINGER ->
4017
+
+ * CAPTURE_START -> READ_IMAGE -> FINALIZE -> VERIFY_RESULT_STATUS ->
4018
+
+ * VERIFY_READY_QUERY -> VERIFY_READY_DECIDE -> SUBMIT_IMAGE ->
4019
+
+ * WAIT_REMOVAL -> REARM -> [cycle_complete -> start_new_cycle]
4020
+
+ */
4021
+
+
4022
+
+static void cycle_run_state(FpiSsm *ssm, FpDevice *dev);
4023
+
+
4024
+
+/*
4025
+
+ * Post-activation settle delay. The device needs a short stabilization window
4026
+
+ * after configuration.
4027
+
+ */
4028
+
+static gboolean
4029
+
+settle_delay_cb(gpointer user_data)
4030
+
+{
4031
+
+ FpiSsm *ssm = user_data;
4032
+
+ FpDevice *dev = fpi_ssm_get_device(ssm);
4033
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
4034
+
+
4035
+
+ self->settle_timeout_id = 0;
4036
+
+
4037
+
+ if (self->deactivating) {
4038
+
+ fpi_ssm_mark_completed(ssm);
4039
+
+ return G_SOURCE_REMOVE;
4040
+
+ }
4041
+
+
4042
+
+ fpi_ssm_next_state(ssm);
4043
+
+ return G_SOURCE_REMOVE;
4044
+
+}
4045
+
+
4046
+
+/* Disabled: early placement delay (kept for reference, Windows parity). */
4047
+
+#if 0
4048
+
+static gboolean
4049
+
+early_placement_delay_cb(gpointer user_data)
4050
+
+{
4051
+
+ FpiSsm *ssm = user_data;
4052
+
+ FpDevice *dev = fpi_ssm_get_device(ssm);
4053
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
4054
+
+
4055
+
+ self->early_timeout_id = 0;
4056
+
+ self->early_placement_detected = FALSE;
4057
+
+
4058
+
+ if (self->deactivating) {
4059
+
+ fpi_ssm_mark_completed(ssm);
4060
+
+ return G_SOURCE_REMOVE;
4061
+
+ }
4062
+
+
4063
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_WAIT_FINGER);
4064
+
+ return G_SOURCE_REMOVE;
4065
+
+}
4066
+
+#endif
4067
+
+
4068
+
+/*
4069
+
+ * Master cycle state machine. This is the authoritative control flow for
4070
+
+ * capture, and is designed to stay as close to Windows behavior as possible.
4071
+
+ */
4072
+
+static void
4073
+
+cycle_run_state(FpiSsm *ssm, FpDevice *dev)
4074
+
+{
4075
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
4076
+
+
4077
+
+ /* Check deactivation at every state entry */
4078
+
+ if (self->deactivating || self->deactivation_in_progress) {
4079
+
+ return;
4080
+
+ }
4081
+
+
4082
+
+ switch (fpi_ssm_get_cur_state(ssm)) {
4083
+
+
4084
+
+ case CYCLE_RECOVERY:
4085
+
+ if (self->force_recovery) {
4086
+
+ fp_warn("Cycle: RECOVERY (hard reset + re-init)");
4087
+
+ } else {
4088
+
+ fp_dbg("Cycle: RECOVERY (no-op)");
4089
+
+ }
4090
+
+ fpi_ssm_next_state(ssm);
4091
+
+ break;
4092
+
+
4093
+
+ case CYCLE_HARD_RESET:
4094
+
+ {
4095
+
+ GUsbDevice *usb = fpi_device_get_usb_device(dev);
4096
+
+ GError *err = NULL;
4097
+
+
4098
+
+ if (self->initial_activation_done && !self->force_recovery) {
4099
+
+ fp_dbg("Cycle: HARD_RESET skipped (rearm mode)");
4100
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_WAIT_FINGER);
4101
+
+ break;
4102
+
+ }
4103
+
+
4104
+
+ fp_dbg("Cycle: HARD_RESET (USB reset + reclaim)");
4105
+
+
4106
+
+ /* Release interface before reset */
4107
+
+ g_usb_device_release_interface(usb, 0, 0, &err);
4108
+
+ g_clear_error(&err);
4109
+
+
4110
+
+ /* USB device reset */
4111
+
+ g_usb_device_reset(usb, &err);
4112
+
+ if (err) {
4113
+
+ fp_warn("USB reset: %s", err->message);
4114
+
+ g_clear_error(&err);
4115
+
+ }
4116
+
+
4117
+
+ /* Reclaim interface */
4118
+
+ if (!g_usb_device_claim_interface(usb, 0,
4119
+
+ G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER, &err)) {
4120
+
+ fpi_ssm_mark_failed(ssm, err);
4121
+
+ return;
4122
+
+ }
4123
+
+
4124
+
+ fpi_ssm_next_state(ssm);
4125
+
+ break;
4126
+
+ }
4127
+
+
4128
+
+ case CYCLE_INIT_CONFIG:
4129
+
+ fp_dbg("Cycle: INIT_CONFIG (activation sub-SSM)");
4130
+
+ {
4131
+
+ FpiSsm *subsm = fpi_ssm_new(dev, activate_run_state,
4132
+
+ STATE_ACTIVATE_NUM_STATES);
4133
+
+ fpi_ssm_start_subsm(ssm, subsm);
4134
+
+ }
4135
+
+ break;
4136
+
+
4137
+
+ case CYCLE_SETTLE_DELAY:
4138
+
+ if (!self->initial_activation_done) {
4139
+
+ self->initial_activation_done = TRUE;
4140
+
+ }
4141
+
+ if (self->force_recovery) {
4142
+
+ self->force_recovery = FALSE;
4143
+
+ }
4144
+
+ fp_dbg("Cycle: SETTLE_DELAY (%dms)", CB2000_WAKEUP_DELAY);
4145
+
+ self->settle_timeout_id = g_timeout_add(CB2000_WAKEUP_DELAY,
4146
+
+ settle_delay_cb, ssm);
4147
+
+ break;
4148
+
+
4149
+
+ case CYCLE_WAIT_FINGER:
4150
+
+ fp_dbg("Cycle: WAIT_FINGER (polling sub-SSM, interval=%dms)",
4151
+
+ CB2000_POLL_INTERVAL);
4152
+
+ /* Reset counters for a new detection window. */
4153
+
+ self->poll_stable_hits = 0;
4154
+
+ self->no_finger_streak = 0;
4155
+
+ self->poll_total_count = 0;
4156
+
+ self->early_placement_detected = FALSE;
4157
+
+ self->poll_start_us = g_get_monotonic_time();
4158
+
+ {
4159
+
+ FpiSsm *subsm = fpi_ssm_new(dev, poll_finger_run_state,
4160
+
+ POLL_FINGER_NUM);
4161
+
+ fpi_ssm_start_subsm(ssm, subsm);
4162
+
+ }
4163
+
+ break;
4164
+
+
4165
+
+ case CYCLE_EARLY_PLACEMENT_DELAY:
4166
+
+ /* Disabled for Windows parity (no early-placement delay). */
4167
+
+ fpi_ssm_next_state(ssm);
4168
+
+ break;
4169
+
+
4170
+
+ case CYCLE_CAPTURE_START:
4171
+
+ {
4172
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4173
+
+ const char *seq_name = cb2000_capture_start_seq_name_for_action(action);
4174
+
+ const Cb2000Command *seq_cmds = cb2000_capture_start_cmds_for_action(action);
4175
+
+ const char *phase_name = cb2000_is_verify_phase_action(action)
4176
+
+ ? "verify_like"
4177
+
+ : "capture_enroll";
4178
+
+
4179
+
+ self->finalize_ack1_len = 0;
4180
+
+ self->finalize_ack2_len = 0;
4181
+
+ memset(self->finalize_ack1, 0, sizeof(self->finalize_ack1));
4182
+
+ memset(self->finalize_ack2, 0, sizeof(self->finalize_ack2));
4183
+
+ self->verify_ack_status_last = 0x00;
4184
+
+ self->verify_ack_decision_last = CB2000_VERIFY_ACK_UNKNOWN;
4185
+
+ self->verify_status_code_last = 0x00;
4186
+
+ self->verify_result_code_last = 0x00;
4187
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_UNKNOWN;
4188
+
+ self->verify_result_class_last = CB2000_VERIFY_RESULT_CLASS_UNKNOWN;
4189
+
+ self->verify_ready_query_len = 0;
4190
+
+ memset(self->verify_ready_query_data, 0, sizeof(self->verify_ready_query_data));
4191
+
+ self->verify_ready_query_status_last = 0x00;
4192
+
+ self->verify_ready_query_b_len = 0;
4193
+
+ memset(self->verify_ready_query_b_data, 0, sizeof(self->verify_ready_query_b_data));
4194
+
+ self->verify_ready_query_b_status_last = 0x00;
4195
+
+ self->verify_ready_matrix_last = CB2000_VERIFY_READY_MATRIX_UNKNOWN;
4196
+
+ self->verify_pre_capture_status_len = 0;
4197
+
+ memset(self->verify_pre_capture_status, 0, sizeof(self->verify_pre_capture_status));
4198
+
+
4199
+
+ fp_info("[ SSM_ROUTE ] action=%s phase=%s state=CAPTURE_START seq=%s",
4200
+
+ cb2000_action_label(action), phase_name, seq_name);
4201
+
+ run_command_sequence(ssm, dev, seq_name, seq_cmds);
4202
+
+ break;
4203
+
+ }
4204
+
+
4205
+
+ case CYCLE_READ_IMAGE:
4206
+
+ fp_dbg("Cycle: READ_IMAGE (20 chunks)");
4207
+
+ self->chunks_read = 0;
4208
+
+ self->image_offset = 0;
4209
+
+ memset(self->image_buffer, 0, CB2000_IMG_SIZE);
4210
+
+ {
4211
+
+ FpiSsm *subsm = fpi_ssm_new(dev, image_read_run_state,
4212
+
+ IMG_READ_NUM);
4213
+
+ fpi_ssm_start_subsm(ssm, subsm);
4214
+
+ }
4215
+
+ break;
4216
+
+
4217
+
+ case CYCLE_FINALIZE:
4218
+
+ {
4219
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4220
+
+ const char *seq_name = cb2000_capture_finalize_seq_name_for_action(action);
4221
+
+ const Cb2000Command *seq_cmds = cb2000_capture_finalize_cmds_for_action(action);
4222
+
+ const char *phase_name = cb2000_is_verify_phase_action(action)
4223
+
+ ? "verify_like"
4224
+
+ : "capture_enroll";
4225
+
+
4226
+
+ fp_info("[ SSM_ROUTE ] action=%s phase=%s state=FINALIZE seq=%s",
4227
+
+ cb2000_action_label(action), phase_name, seq_name);
4228
+
+ run_command_sequence(ssm, dev, seq_name, seq_cmds);
4229
+
+ break;
4230
+
+ }
4231
+
+
4232
+
+ case CYCLE_VERIFY_RESULT_STATUS:
4233
+
+ {
4234
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4235
+
+ guint attempt = self->submit_verify_total + 1;
4236
+
+ gboolean gate_retry = FALSE;
4237
+
+
4238
+
+ if (!cb2000_is_verify_phase_action(action)) {
4239
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_SUBMIT_IMAGE);
4240
+
+ break;
4241
+
+ }
4242
+
+
4243
+
+ gate_retry = cb2000_verify_finalize_ack_gate(dev, self);
4244
+
+
4245
+
+ if (gate_retry) {
4246
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_RETRY_GATE;
4247
+
+ fp_info("[ VERIFY_RESULT ] attempt=%u decision=%s result_class=%s status=0x%02x result=0x%02x route=%s experimental=%d status_short=%d",
4248
+
+ attempt,
4249
+
+ cb2000_verify_ack_decision_label(self->verify_ack_decision_last),
4250
+
+ cb2000_verify_result_class_label(self->verify_result_class_last),
4251
+
+ self->verify_status_code_last,
4252
+
+ self->verify_result_code_last,
4253
+
+ cb2000_verify_route_label(self->verify_route_last),
4254
+
+ self->experimental_device_assisted_verify,
4255
+
+ self->verify_device_status_short_circuit);
4256
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_WAIT_REMOVAL);
4257
+
+ break;
4258
+
+ }
4259
+
+
4260
+
+ switch (self->verify_ack_decision_last) {
4261
+
+ case CB2000_VERIFY_ACK_RETRY:
4262
+
+ /* Retry already handled by finalize_ack_gate; fall through to NBIS. */
4263
+
+
4264
+
+ case CB2000_VERIFY_ACK_DEVICE_NOMATCH:
4265
+
+ if (self->verify_device_status_short_circuit ||
4266
+
+ self->experimental_device_assisted_verify) {
4267
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_DEVICE_NOMATCH;
4268
+
+ fp_info("[ VERIFY_RESULT ] attempt=%u decision=%s result_class=%s status=0x%02x result=0x%02x route=%s experimental=%d status_short=%d",
4269
+
+ attempt,
4270
+
+ cb2000_verify_ack_decision_label(self->verify_ack_decision_last),
4271
+
+ cb2000_verify_result_class_label(self->verify_result_class_last),
4272
+
+ self->verify_status_code_last,
4273
+
+ self->verify_result_code_last,
4274
+
+ cb2000_verify_route_label(self->verify_route_last),
4275
+
+ self->experimental_device_assisted_verify,
4276
+
+ self->verify_device_status_short_circuit);
4277
+
+ fpi_device_verify_report(dev, FPI_MATCH_FAIL, NULL, NULL);
4278
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_WAIT_REMOVAL);
4279
+
+ break;
4280
+
+ }
4281
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_HOST_NBIS;
4282
+
+ fp_info("[ VERIFY_RESULT ] attempt=%u decision=%s result_class=%s status=0x%02x result=0x%02x route=%s experimental=%d status_short=%d",
4283
+
+ attempt,
4284
+
+ cb2000_verify_ack_decision_label(self->verify_ack_decision_last),
4285
+
+ cb2000_verify_result_class_label(self->verify_result_class_last),
4286
+
+ self->verify_status_code_last,
4287
+
+ self->verify_result_code_last,
4288
+
+ cb2000_verify_route_label(self->verify_route_last),
4289
+
+ self->experimental_device_assisted_verify,
4290
+
+ self->verify_device_status_short_circuit);
4291
+
+ fpi_ssm_next_state(ssm);
4292
+
+ break;
4293
+
+
4294
+
+ case CB2000_VERIFY_ACK_READY:
4295
+
+ if (self->experimental_device_assisted_verify) {
4296
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_DEVICE_STATUS;
4297
+
+ } else {
4298
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_HOST_NBIS;
4299
+
+ }
4300
+
+ fp_info("[ VERIFY_RESULT ] attempt=%u decision=%s result_class=%s status=0x%02x result=0x%02x route=%s experimental=%d status_short=%d",
4301
+
+ attempt,
4302
+
+ cb2000_verify_ack_decision_label(self->verify_ack_decision_last),
4303
+
+ cb2000_verify_result_class_label(self->verify_result_class_last),
4304
+
+ self->verify_status_code_last,
4305
+
+ self->verify_result_code_last,
4306
+
+ cb2000_verify_route_label(self->verify_route_last),
4307
+
+ self->experimental_device_assisted_verify,
4308
+
+ self->verify_device_status_short_circuit);
4309
+
+ if (self->verify_ready_query_enabled) {
4310
+
+ fp_info("[ VERIFY_RESULT ] READY -> entering complementary status query");
4311
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_VERIFY_READY_QUERY_A);
4312
+
+ } else {
4313
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_SUBMIT_IMAGE);
4314
+
+ }
4315
+
+ break;
4316
+
+
4317
+
+ case CB2000_VERIFY_ACK_UNKNOWN:
4318
+
+ default:
4319
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_UNKNOWN;
4320
+
+ fp_info("[ VERIFY_RESULT ] attempt=%u decision=%s result_class=%s status=0x%02x result=0x%02x route=%s experimental=%d status_short=%d",
4321
+
+ attempt,
4322
+
+ cb2000_verify_ack_decision_label(self->verify_ack_decision_last),
4323
+
+ cb2000_verify_result_class_label(self->verify_result_class_last),
4324
+
+ self->verify_status_code_last,
4325
+
+ self->verify_result_code_last,
4326
+
+ cb2000_verify_route_label(self->verify_route_last),
4327
+
+ self->experimental_device_assisted_verify,
4328
+
+ self->verify_device_status_short_circuit);
4329
+
+ fpi_ssm_next_state(ssm);
4330
+
+ break;
4331
+
+ }
4332
+
+ break;
4333
+
+ }
4334
+
+
4335
+
+ case CYCLE_VERIFY_READY_QUERY_A:
4336
+
+ {
4337
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4338
+
+
4339
+
+ if (!cb2000_is_verify_phase_action(action) || !self->verify_ready_query_enabled) {
4340
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_SUBMIT_IMAGE);
4341
+
+ break;
4342
+
+ }
4343
+
+
4344
+
+ self->verify_ready_query_len = 0;
4345
+
+ memset(self->verify_ready_query_data, 0, sizeof(self->verify_ready_query_data));
4346
+
+ self->verify_ready_query_status_last = 0x00;
4347
+
+
4348
+
+ fp_info("[ SSM_ROUTE ] action=%s phase=verify_like state=VERIFY_READY_QUERY_A",
4349
+
+ cb2000_action_label(action));
4350
+
+ run_command_sequence(ssm, dev, "verify_ready_query_a", verify_ready_query_a_cmds);
4351
+
+ break;
4352
+
+ }
4353
+
+
4354
+
+ case CYCLE_VERIFY_READY_QUERY_B:
4355
+
+ {
4356
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4357
+
+
4358
+
+ if (!cb2000_is_verify_phase_action(action) || !self->verify_ready_query_enabled) {
4359
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_SUBMIT_IMAGE);
4360
+
+ break;
4361
+
+ }
4362
+
+
4363
+
+ if (!self->verify_ready_query_b_enabled) {
4364
+
+ fp_dbg("[ VERIFY_READY_QUERY_B ] disabled -> skipping");
4365
+
+ fpi_ssm_next_state(ssm);
4366
+
+ break;
4367
+
+ }
4368
+
+
4369
+
+ self->verify_ready_query_b_len = 0;
4370
+
+ memset(self->verify_ready_query_b_data, 0, sizeof(self->verify_ready_query_b_data));
4371
+
+ self->verify_ready_query_b_status_last = 0x00;
4372
+
+
4373
+
+ fp_info("[ SSM_ROUTE ] action=%s phase=verify_like state=VERIFY_READY_QUERY_B",
4374
+
+ cb2000_action_label(action));
4375
+
+ run_command_sequence(ssm, dev, "verify_ready_query_b", verify_ready_query_b_cmds);
4376
+
+ break;
4377
+
+ }
4378
+
+
4379
+
+ case CYCLE_VERIFY_READY_DECIDE:
4380
+
+ {
4381
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4382
+
+ guint8 status_a = self->verify_ready_query_status_last;
4383
+
+ guint8 status_b = self->verify_ready_query_b_status_last;
4384
+
+ gboolean has_b = self->verify_ready_query_b_enabled &&
4385
+
+ (self->verify_ready_query_b_len > 0);
4386
+
+ Cb2000VerifyReadyMatrixDecision matrix;
4387
+
+
4388
+
+ if (!cb2000_is_verify_phase_action(action) || !self->verify_ready_query_enabled) {
4389
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_SUBMIT_IMAGE);
4390
+
+ break;
4391
+
+ }
4392
+
+
4393
+
+ matrix = cb2000_decide_ready_query_matrix(status_a, has_b, status_b);
4394
+
+ self->verify_ready_matrix_last = matrix;
4395
+
+
4396
+
+ if (has_b) {
4397
+
+ fp_info("[ VERIFY_READY_MATRIX ] A=0x%02x(%s) B=0x%02x(%s) => %s",
4398
+
+ status_a,
4399
+
+ cb2000_verify_ready_query_class_label(status_a),
4400
+
+ status_b,
4401
+
+ cb2000_verify_ready_query_class_label(status_b),
4402
+
+ cb2000_verify_ready_matrix_label(matrix));
4403
+
+ } else {
4404
+
+ fp_info("[ VERIFY_READY_MATRIX ] A=0x%02x(%s) B=N/A => %s",
4405
+
+ status_a,
4406
+
+ cb2000_verify_ready_query_class_label(status_a),
4407
+
+ cb2000_verify_ready_matrix_label(matrix));
4408
+
+ }
4409
+
+
4410
+
+ switch (matrix) {
4411
+
+ case CB2000_VERIFY_READY_MATRIX_READY:
4412
+
+ self->verify_ready_query_ready_total++;
4413
+
+ self->verify_ready_matrix_ready_total++;
4414
+
+ /* Keep conservative fallback to NBIS until MoC decision table is closed. */
4415
+
+ if (self->verify_route_last == CB2000_VERIFY_ROUTE_DEVICE_STATUS)
4416
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_HOST_NBIS;
4417
+
+ fpi_ssm_next_state(ssm);
4418
+
+ break;
4419
+
+
4420
+
+ case CB2000_VERIFY_READY_MATRIX_RETRY:
4421
+
+ self->verify_ready_query_retry_total++;
4422
+
+ self->verify_ready_matrix_retry_total++;
4423
+
+ cb2000_retry_scan_with_cause(dev, CB2000_RETRY_DEVICE_STATUS,
4424
+
+ "(verify ready matrix retry)");
4425
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_WAIT_REMOVAL);
4426
+
+ break;
4427
+
+
4428
+
+ case CB2000_VERIFY_READY_MATRIX_DEVICE_NOMATCH:
4429
+
+ self->verify_ready_query_nomatch_total++;
4430
+
+ self->verify_ready_matrix_nomatch_total++;
4431
+
+ if (self->verify_device_status_short_circuit) {
4432
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_DEVICE_NOMATCH;
4433
+
+ fpi_device_verify_report(dev, FPI_MATCH_FAIL, NULL, NULL);
4434
+
+ fpi_ssm_jump_to_state(ssm, CYCLE_WAIT_REMOVAL);
4435
+
+ } else {
4436
+
+ fpi_ssm_next_state(ssm);
4437
+
+ }
4438
+
+ break;
4439
+
+
4440
+
+ case CB2000_VERIFY_READY_MATRIX_UNKNOWN:
4441
+
+ default:
4442
+
+ self->verify_ready_query_unknown_total++;
4443
+
+ self->verify_ready_matrix_unknown_total++;
4444
+
+ fpi_ssm_next_state(ssm);
4445
+
+ break;
4446
+
+ }
4447
+
+ break;
4448
+
+ }
4449
+
+
4450
+
+ case CYCLE_SUBMIT_IMAGE:
4451
+
+ fp_dbg("Cycle: SUBMIT_IMAGE (got %zu/%d bytes)",
4452
+
+ self->image_offset, CB2000_IMG_SIZE);
4453
+
+
4454
+
+ /* === RAW DUMP ===
4455
+
+ * Enabled only for debugging and protocol validation. */
4456
+
+ #if CB2000_RAW_DUMP_ENABLED
4457
+
+ {
4458
+
+ time_t now = time(NULL);
4459
+
+ struct tm *tm_info = localtime(&now);
4460
+
+ char timestamp[32];
4461
+
+ strftime(timestamp, sizeof(timestamp), "%Y%m%d_%H%M%S", tm_info);
4462
+
+ const gchar *out_dir = cb2000_get_output_dir();
4463
+
+ g_autofree gchar *dump_name = g_strdup_printf("canvasbio_%s.raw", timestamp);
4464
+
+ g_autofree gchar *dump_path = NULL;
4465
+
+
4466
+
+ g_mkdir_with_parents(out_dir, 0755);
4467
+
+ dump_path = g_build_filename(out_dir, dump_name, NULL);
4468
+
+
4469
+
+ if (g_file_set_contents(dump_path,
4470
+
+ (const gchar *)self->image_buffer,
4471
+
+ self->image_offset, NULL)) {
4472
+
+ fp_info("RAW DUMP: %zu bytes -> %s", self->image_offset, dump_path);
4473
+
+ } else {
4474
+
+ fp_warn("RAW DUMP: failed to save %s", dump_path);
4475
+
+ }
4476
+
+ }
4477
+
+ #endif
4478
+
+
4479
+
+ /* Create and submit image to libfprint for MoH processing. */
4480
+
+ {
4481
+
+ FpImage *img = fp_image_new(CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
4482
+
+ img->ppmm = cb2000_get_ppmm();
4483
+
+
4484
+
+ gsize copy_len = MIN(self->image_offset, CB2000_IMG_SIZE);
4485
+
+ memcpy(img->data, self->image_buffer, copy_len);
4486
+
+
4487
+
+ if (copy_len < CB2000_IMG_SIZE) {
4488
+
+ memset(img->data + copy_len, 0x00,
4489
+
+ CB2000_IMG_SIZE - copy_len);
4490
+
+ }
4491
+
+
4492
+
+ double variance = calculate_variance(img->data,
4493
+
+ CB2000_IMG_WIDTH,
4494
+
+ CB2000_IMG_HEIGHT);
4495
+
+ double low_var_ratio = calculate_block_low_var_ratio(
4496
+
+ img->data, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
4497
+
+ CB2000_BLOCK_SIZE, CB2000_LOW_VAR_THRESHOLD);
4498
+
+ double focus_var = calculate_laplacian_variance(
4499
+
+ img->data, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
4500
+
+ fp_info("Image variance: %.1f low_var_ratio=%.2f focus=%.1f",
4501
+
+ variance, low_var_ratio, focus_var);
4502
+
+ fp_info("Detect reg51=%s, Capture reg51=%s",
4503
+
+ CB2000_USE_ALT_DETECT_51 ? "0x68" : "0xA8",
4504
+
+ "0x88");
4505
+
+
4506
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4507
+
+ gboolean use_bg_subtract = cb2000_should_apply_bg_subtraction(action);
4508
+
+
4509
+
+ if (cb2000_is_verify_phase_action(action)) {
4510
+
+ fp_info("[ SSM_ROUTE ] action=%s phase=verify_like state=SUBMIT_IMAGE route=%s",
4511
+
+ cb2000_action_label(action),
4512
+
+ cb2000_verify_route_label(self->verify_route_last));
4513
+
+ } else {
4514
+
+ fp_dbg("[ SSM_ROUTE ] action=%s phase=capture_enroll state=SUBMIT_IMAGE route=HOST_PREPROCESS",
4515
+
+ cb2000_action_label(action));
4516
+
+ }
4517
+
+
4518
+
+ /*
4519
+
+ * Background bootstrap is useful for capture/enroll only.
4520
+
+ * In verify/identify, Windows parity relies on finalize ACK routing,
4521
+
+ * so a low-variance frame should not be re-labeled as background.
4522
+
+ */
4523
+
+ if (!cb2000_is_verify_phase_action(action) &&
4524
+
+ !self->background_valid &&
4525
+
+ variance < CB2000_BG_CAPTURE_MAX_VARIANCE) {
4526
+
+ memcpy(self->background_buffer, img->data, CB2000_IMG_SIZE);
4527
+
+ self->background_valid = TRUE;
4528
+
+ fp_info("Background captured (variance %.1f) - retrying capture",
4529
+
+ variance);
4530
+
+ g_object_unref(img);
4531
+
+ cb2000_retry_scan_with_cause(dev,
4532
+
+ CB2000_RETRY_BACKGROUND_CAPTURE,
4533
+
+ "(capture background)");
4534
+
+ fpi_ssm_next_state(ssm);
4535
+
+ return;
4536
+
+ }
4537
+
+
4538
+
+ if (self->background_valid && use_bg_subtract) {
4539
+
+ apply_background_subtraction(img->data,
4540
+
+ self->background_buffer,
4541
+
+ CB2000_IMG_WIDTH,
4542
+
+ CB2000_IMG_HEIGHT);
4543
+
+ }
4544
+
+
4545
+
+ /* CLAHE: local contrast enhancement on raw image before upscale.
4546
+
+ * This is the key preprocessing for NBIS on small sensors. */
4547
+
+ apply_clahe(img->data, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
4548
+
+ CB2000_CLAHE_TILE_W, CB2000_CLAHE_TILE_H,
4549
+
+ CB2000_CLAHE_CLIP_LIMIT);
4550
+
+
4551
+
+ normalize_contrast(img->data, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
4552
+
+ /* Polarity: keep raw sensor orientation (white ridges on black). */
4553
+
+ /* invert_image_u8(img->data, CB2000_IMG_SIZE); */
4554
+
+
4555
+
+ double variance_norm = calculate_variance(img->data,
4556
+
+ CB2000_IMG_WIDTH,
4557
+
+ CB2000_IMG_HEIGHT);
4558
+
+ double low_var_ratio_norm = calculate_block_low_var_ratio(
4559
+
+ img->data, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT,
4560
+
+ CB2000_BLOCK_SIZE, CB2000_LOW_VAR_THRESHOLD);
4561
+
+ fp_info("Image variance (normalized): %.1f low_var_ratio=%.2f",
4562
+
+ variance_norm, low_var_ratio_norm);
4563
+
+
4564
+
+ const int area_min_pct = cb2000_get_area_min_pct(action);
4565
+
+
4566
+
+ double area_ratio_norm = calculate_fingerprint_area_ratio(
4567
+
+ img->data, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
4568
+
+ int area_pct = (int)(area_ratio_norm * 100.0 + 0.5);
4569
+
+ int overlap_pct = -1;
4570
+
+ if (self->previous_norm_valid && self->previous_norm_buffer) {
4571
+
+ overlap_pct = calculate_overlap_percent(img->data,
4572
+
+ self->previous_norm_buffer,
4573
+
+ CB2000_IMG_SIZE);
4574
+
+ }
4575
+
+ int quality_score = calculate_quality_score(variance_norm,
4576
+
+ focus_var,
4577
+
+ area_ratio_norm);
4578
+
+ fp_info("[ IMAGE ] quality = %d, area = %d, overlap = %d",
4579
+
+ quality_score, area_pct, overlap_pct);
4580
+
+
4581
+
+ gboolean fail_area = (area_pct < area_min_pct);
4582
+
+ gboolean fail_variance = (variance_norm < CB2000_MIN_IMAGE_VARIANCE);
4583
+
+ gboolean fail_focus = (focus_var < CB2000_MIN_FOCUS_VARIANCE);
4584
+
+
4585
+
+ if (fail_area) {
4586
+
+ fp_warn("Reject! quality.fingerprint_area %d < %d (threshold)",
4587
+
+ area_pct, area_min_pct);
4588
+
+ }
4589
+
+
4590
+
+ if (fail_variance || fail_area || fail_focus) {
4591
+
+ fp_warn("Reject! Image quality too bad. var=%.1f area=%d focus=%.1f overlap=%d",
4592
+
+ variance_norm, area_pct, focus_var, overlap_pct);
4593
+
+ fp_info("[ GATE ] action=%s min_area=%d fail_var=%d fail_area=%d fail_focus=%d",
4594
+
+ cb2000_action_label(action), area_min_pct,
4595
+
+ fail_variance, fail_area, fail_focus);
4596
+
+ if (self->previous_norm_buffer) {
4597
+
+ memcpy(self->previous_norm_buffer, img->data, CB2000_IMG_SIZE);
4598
+
+ self->previous_norm_valid = TRUE;
4599
+
+ }
4600
+
+ g_object_unref(img);
4601
+
+ /* Avoid misleading "finger not centered" when failure is just quality/coverage. */
4602
+
+ cb2000_retry_scan_with_cause(dev,
4603
+
+ fail_area
4604
+
+ ? CB2000_RETRY_AREA_GATE
4605
+
+ : CB2000_RETRY_QUALITY_GATE,
4606
+
+ "(quality gate)");
4607
+
+ fpi_ssm_next_state(ssm);
4608
+
+ return;
4609
+
+ }
4610
+
+
4611
+
+ /* Let libfprint invert for matching (see fp-image.c). */
4612
+
+ img->flags = FPI_IMAGE_COLORS_INVERTED;
4613
+
+
4614
+
+ /* Optional upscale to improve NBIS minutiae extraction on small images. */
4615
+
+ int upscale = cb2000_get_upscale_factor(action);
4616
+
+ fp_dbg("Preprocess profile: action=%s bg_subtract=%d upscale=%dx",
4617
+
+ cb2000_action_label(action), use_bg_subtract, upscale);
4618
+
+ if (upscale > 1) {
4619
+
+ FpImage *resized = fpi_image_resize(img, upscale, upscale);
4620
+
+ if (resized) {
4621
+
+ resized->flags = img->flags;
4622
+
+ resized->ppmm = img->ppmm * upscale;
4623
+
+ /* Smooth bilinear upscale artifacts for NBIS ridge detection. */
4624
+
+ gaussian_blur_3x3(resized->data, resized->width,
4625
+
+ resized->height);
4626
+
+ g_object_unref(img);
4627
+
+ img = resized;
4628
+
+ }
4629
+
+ }
4630
+
+
4631
+
+ /* Save action-scoped PGM for debug (latest frame always available). */
4632
+
+ cb2000_save_debug_pgm(img, action);
4633
+
+
4634
+
+ if (cb2000_dump_binarized_enabled()) {
4635
+
+ FpImage *dbg = fp_image_new(CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
4636
+
+ dbg->ppmm = img->ppmm;
4637
+
+ dbg->flags = img->flags;
4638
+
+ memcpy(dbg->data, img->data, CB2000_IMG_SIZE);
4639
+
+
4640
+
+ g_autofree gchar *label =
4641
+
+ g_strdup(cb2000_action_label(action));
4642
+
+ fp_image_detect_minutiae(dbg, NULL, cb2000_dump_binarized_cb,
4643
+
+ g_steal_pointer(&label));
4644
+
+ }
4645
+
+
4646
+
+ fp_info("Captured fingerprint: %zu bytes (%dx%d)",
4647
+
+ self->image_offset, img->width, img->height);
4648
+
+
4649
+
+ if (self->previous_norm_buffer) {
4650
+
+ memcpy(self->previous_norm_buffer, img->data, CB2000_IMG_SIZE);
4651
+
+ self->previous_norm_valid = TRUE;
4652
+
+ }
4653
+
+
4654
+
+ gboolean precheck_enabled = cb2000_should_precheck_minutiae(action);
4655
+
+ fp_dbg("Precheck profile: action=%s precheck=%d",
4656
+
+ cb2000_action_label(action), precheck_enabled);
4657
+
+
4658
+
+ if (precheck_enabled) {
4659
+
+ Cb2000MinutiaePrecheckCtx *ctx = g_new0(Cb2000MinutiaePrecheckCtx, 1);
4660
+
+ ctx->dev = dev;
4661
+
+ ctx->ssm = ssm;
4662
+
+ ctx->img = img;
4663
+
+ ctx->action = action;
4664
+
+ fp_image_detect_minutiae(img, NULL, cb2000_minutiae_precheck_cb, ctx);
4665
+
+ return;
4666
+
+ }
4667
+
+
4668
+
+ cb2000_update_submit_telemetry(self, dev, action);
4669
+
+ self->accepted_total++;
4670
+
+
4671
+
+ /* Action-specific handling (V33 FpDevice + NCC) */
4672
+
+ {
4673
+
+ if (action == FPI_DEVICE_ACTION_CAPTURE) {
4674
+
+ fpi_device_capture_complete(dev, img, NULL);
4675
+
+ fpi_ssm_mark_completed(ssm);
4676
+
+ return;
4677
+
+
4678
+
+ } else if (action == FPI_DEVICE_ACTION_ENROLL) {
4679
+
+ guint8 *norm = g_malloc(CB2000_IMG_SIZE);
4680
+
+ memcpy(norm, img->data, CB2000_IMG_SIZE);
4681
+
+ normalize_contrast(norm, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
4682
+
+ g_clear_pointer(&self->enroll_images[self->enroll_stage], g_free);
4683
+
+ self->enroll_images[self->enroll_stage] = norm;
4684
+
+ self->enroll_stage++;
4685
+
+ g_object_unref(img);
4686
+
+
4687
+
+ fp_info("Enrollment stage %d/%d complete",
4688
+
+ self->enroll_stage, CB2000_NR_ENROLL_STAGES);
4689
+
+
4690
+
+ if (self->enroll_stage >= CB2000_NR_ENROLL_STAGES) {
4691
+
+ fpi_ssm_mark_completed(ssm);
4692
+
+ } else {
4693
+
+ fpi_device_enroll_progress(dev, self->enroll_stage, NULL, NULL);
4694
+
+ fpi_ssm_next_state(ssm); /* -> WAIT_REMOVAL -> REARM -> new cycle */
4695
+
+ }
4696
+
+ return;
4697
+
+
4698
+
+ } else if (action == FPI_DEVICE_ACTION_VERIFY ||
4699
+
+ action == FPI_DEVICE_ACTION_IDENTIFY) {
4700
+
+ FpPrint *enrolled = NULL;
4701
+
+ guint8 norm[CB2000_IMG_SIZE];
4702
+
+ Cb2000NccTelemetry ncc_tel;
4703
+
+ Cb2000NccDecision ncc_decision = CB2000_NCC_DECISION_ERROR;
4704
+
+
4705
+
+ memcpy(norm, img->data, CB2000_IMG_SIZE);
4706
+
+ normalize_contrast(norm, CB2000_IMG_WIDTH, CB2000_IMG_HEIGHT);
4707
+
+ g_object_unref(img);
4708
+
+
4709
+
+ fpi_device_get_verify_data(dev, &enrolled);
4710
+
+ if (enrolled && unpack_and_match(enrolled, norm, &ncc_tel)) {
4711
+
+ ncc_decision = cb2000_ncc_classify(&ncc_tel);
4712
+
+ switch (ncc_decision) {
4713
+
+ case CB2000_NCC_DECISION_MATCH:
4714
+
+ self->verify_result = FPI_MATCH_SUCCESS;
4715
+
+ break;
4716
+
+ case CB2000_NCC_DECISION_NO_MATCH:
4717
+
+ self->verify_result = FPI_MATCH_FAIL;
4718
+
+ break;
4719
+
+ case CB2000_NCC_DECISION_RETRY:
4720
+
+ self->verify_result = FPI_MATCH_ERROR;
4721
+
+ break;
4722
+
+ case CB2000_NCC_DECISION_ERROR:
4723
+
+ default:
4724
+
+ self->verify_result = FPI_MATCH_ERROR;
4725
+
+ break;
4726
+
+ }
4727
+
+ } else {
4728
+
+ self->verify_result = FPI_MATCH_ERROR;
4729
+
+ }
4730
+
+
4731
+
+ fp_info("[ NCC ] decision=%s -> result=%s",
4732
+
+ cb2000_ncc_decision_label(ncc_decision),
4733
+
+ self->verify_result == FPI_MATCH_SUCCESS ? "MATCH" :
4734
+
+ self->verify_result == FPI_MATCH_FAIL ? "NO MATCH" : "ERROR");
4735
+
+
4736
+
+ fpi_ssm_mark_completed(ssm);
4737
+
+ return;
4738
+
+
4739
+
+ } else {
4740
+
+ g_object_unref(img);
4741
+
+ fpi_ssm_next_state(ssm);
4742
+
+ return;
4743
+
+ }
4744
+
+ }
4745
+
+ }
4746
+
+ break;
4747
+
+
4748
+
+ case CYCLE_WAIT_REMOVAL:
4749
+
+ fp_dbg("Cycle: WAIT_REMOVAL (polling sub-SSM)");
4750
+
+ self->removal_poll_count = 0;
4751
+
+ self->removal_stable_off_hits = 0;
4752
+
+ self->removal_start_us = g_get_monotonic_time();
4753
+
+ {
4754
+
+ FpiSsm *subsm = fpi_ssm_new(dev, poll_removal_run_state,
4755
+
+ POLL_REMOVAL_NUM);
4756
+
+ fpi_ssm_start_subsm(ssm, subsm);
4757
+
+ }
4758
+
+ break;
4759
+
+
4760
+
+ case CYCLE_REARM:
4761
+
+ fp_dbg("Cycle: REARM (soft reset + detection rearm)");
4762
+
+ run_command_sequence(ssm, dev, "rearm", rearm_cmds);
4763
+
+ break;
4764
+
+ }
4765
+
+}
4766
+
+
4767
+
+/*
4768
+
+ * Cycle completion handler. Cancels any pending timers, handles recovery,
4769
+
+ * and starts the next cycle unless deactivation is in progress.
4770
+
+ */
4771
+
+static void
4772
+
+cycle_complete(FpiSsm *ssm, FpDevice *dev, GError *error)
4773
+
+{
4774
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
4775
+
+ self->cycle_ssm = NULL;
4776
+
+
4777
+
+ /* Cancel settle timer if pending */
4778
+
+ if (self->settle_timeout_id > 0) {
4779
+
+ g_source_remove(self->settle_timeout_id);
4780
+
+ self->settle_timeout_id = 0;
4781
+
+ }
4782
+
+ if (self->poll_timeout_id > 0) {
4783
+
+ g_source_remove(self->poll_timeout_id);
4784
+
+ self->poll_timeout_id = 0;
4785
+
+ }
4786
+
+ if (self->removal_timeout_id > 0) {
4787
+
+ g_source_remove(self->removal_timeout_id);
4788
+
+ self->removal_timeout_id = 0;
4789
+
+ }
4790
+
+ if (self->early_timeout_id > 0) {
4791
+
+ g_source_remove(self->early_timeout_id);
4792
+
+ self->early_timeout_id = 0;
4793
+
+ }
4794
+
+ if (self->deactivation_timeout_id > 0) {
4795
+
+ g_source_remove(self->deactivation_timeout_id);
4796
+
+ self->deactivation_timeout_id = 0;
4797
+
+ }
4798
+
+
4799
+
+ if (self->deactivating) {
4800
+
+ g_clear_error(&error);
4801
+
+ complete_deactivation(dev);
4802
+
+ return;
4803
+
+ }
4804
+
+
4805
+
+ if (error) {
4806
+
+ fp_warn("Cycle failed: %s - starting new cycle (recovery)",
4807
+
+ error->message);
4808
+
+ g_error_free(error);
4809
+
+ self->force_recovery = TRUE;
4810
+
+ start_new_cycle(dev);
4811
+
+ return;
4812
+
+ }
4813
+
+
4814
+
+ fp_dbg("[ STATS ] accepted=%u retry_total=%u bg=%u area=%u quality=%u precheck=%u dev_status=%u "
4815
+
+ "submit_cap=%u submit_enroll=%u submit_verify=%u submit_identify=%u "
4816
+
+ "verify_subprints_last=%u min=%u max=%u verify_rx=%u rx_nonzero=%u "
4817
+
+ "ack1=%02x:%02x:%02x:%02x ack2=%02x:%02x:%02x:%02x "
4818
+
+ "ack_ready=%u ack_retry=%u ack_nomatch=%u ack_unknown=%u ack_mismatch=%u "
4819
+
+ "verify_status=0x%02x verify_result=0x%02x verify_route=%s "
4820
+
+ "result_class=%s rc_ready=%u rc_retry=%u rc_nomatch=%u rc_unknown=%u status_short=%d "
4821
+
+ "ready_query_en=%d ready_query_total=%u ready_query_status=0x%02x "
4822
+
+ "ready_query_b_en=%d ready_query_b_total=%u ready_query_b_status=0x%02x "
4823
+
+ "rq_ready=%u rq_retry=%u rq_nomatch=%u rq_unknown=%u "
4824
+
+ "rq_matrix=%s m_ready=%u m_retry=%u m_nomatch=%u m_unknown=%u "
4825
+
+ "pre_cap_total=%u pre_cap_len=%zu pre_cap=%02x:%02x:%02x:%02x",
4826
+
+ self->accepted_total,
4827
+
+ self->retry_total,
4828
+
+ self->retry_cause_count[CB2000_RETRY_BACKGROUND_CAPTURE],
4829
+
+ self->retry_cause_count[CB2000_RETRY_AREA_GATE],
4830
+
+ self->retry_cause_count[CB2000_RETRY_QUALITY_GATE],
4831
+
+ self->retry_cause_count[CB2000_RETRY_MINUTIAE_PRECHECK],
4832
+
+ self->retry_cause_count[CB2000_RETRY_DEVICE_STATUS],
4833
+
+ self->submit_capture_total,
4834
+
+ self->submit_enroll_total,
4835
+
+ self->submit_verify_total,
4836
+
+ self->submit_identify_total,
4837
+
+ self->verify_template_subprints_last,
4838
+
+ self->verify_template_subprints_min,
4839
+
+ self->verify_template_subprints_max,
4840
+
+ self->verify_cmd_rx_total,
4841
+
+ self->verify_cmd_rx_with_data,
4842
+
+ self->finalize_ack1[0], self->finalize_ack1[1],
4843
+
+ self->finalize_ack1[2], self->finalize_ack1[3],
4844
+
+ self->finalize_ack2[0], self->finalize_ack2[1],
4845
+
+ self->finalize_ack2[2], self->finalize_ack2[3],
4846
+
+ self->verify_ack_ready_total,
4847
+
+ self->verify_ack_retry_total,
4848
+
+ self->verify_ack_nomatch_total,
4849
+
+ self->verify_ack_unknown_total,
4850
+
+ self->verify_ack_mismatch_total,
4851
+
+ self->verify_status_code_last,
4852
+
+ self->verify_result_code_last,
4853
+
+ cb2000_verify_route_label(self->verify_route_last),
4854
+
+ cb2000_verify_result_class_label(self->verify_result_class_last),
4855
+
+ self->verify_result_class_count[CB2000_VERIFY_RESULT_CLASS_READY],
4856
+
+ self->verify_result_class_count[CB2000_VERIFY_RESULT_CLASS_RETRY],
4857
+
+ self->verify_result_class_count[CB2000_VERIFY_RESULT_CLASS_DEVICE_NOMATCH],
4858
+
+ self->verify_result_class_count[CB2000_VERIFY_RESULT_CLASS_UNKNOWN],
4859
+
+ self->verify_device_status_short_circuit,
4860
+
+ self->verify_ready_query_enabled,
4861
+
+ self->verify_ready_query_total,
4862
+
+ self->verify_ready_query_status_last,
4863
+
+ self->verify_ready_query_b_enabled,
4864
+
+ self->verify_ready_query_b_total,
4865
+
+ self->verify_ready_query_b_status_last,
4866
+
+ self->verify_ready_query_ready_total,
4867
+
+ self->verify_ready_query_retry_total,
4868
+
+ self->verify_ready_query_nomatch_total,
4869
+
+ self->verify_ready_query_unknown_total,
4870
+
+ cb2000_verify_ready_matrix_label(self->verify_ready_matrix_last),
4871
+
+ self->verify_ready_matrix_ready_total,
4872
+
+ self->verify_ready_matrix_retry_total,
4873
+
+ self->verify_ready_matrix_nomatch_total,
4874
+
+ self->verify_ready_matrix_unknown_total,
4875
+
+ self->verify_pre_capture_status_total,
4876
+
+ self->verify_pre_capture_status_len,
4877
+
+ self->verify_pre_capture_status[0],
4878
+
+ self->verify_pre_capture_status[1],
4879
+
+ self->verify_pre_capture_status[2],
4880
+
+ self->verify_pre_capture_status[3]);
4881
+
+ fp_dbg("Cycle complete, checking action-specific completion");
4882
+
+
4883
+
+ {
4884
+
+ FpiDeviceAction action = fpi_device_get_current_action(dev);
4885
+
+
4886
+
+ /* Action-specific completion for FpDevice */
4887
+
+ if (action == FPI_DEVICE_ACTION_ENROLL) {
4888
+
+ if (self->enroll_stage >= CB2000_NR_ENROLL_STAGES) {
4889
+
+ /* All stages done - pack and complete */
4890
+
+ FpPrint *print = NULL;
4891
+
+ fpi_device_get_enroll_data(dev, &print);
4892
+
+ pack_enrollment_data(self, print);
4893
+
+ fp_info("Enrollment complete (%d stages)", CB2000_NR_ENROLL_STAGES);
4894
+
+ fpi_device_enroll_complete(dev, g_object_ref(print), NULL);
4895
+
+ return;
4896
+
+ }
4897
+
+ /* More stages: fall through to start_new_cycle */
4898
+
+ } else if (action == FPI_DEVICE_ACTION_VERIFY ||
4899
+
+ action == FPI_DEVICE_ACTION_IDENTIFY) {
4900
+
+ if (self->verify_retry_pending) {
4901
+
+ GError *err = NULL;
4902
+
+ if (self->verify_retry_message[0] != '\0') {
4903
+
+ err = fpi_device_retry_new_msg(self->verify_retry_error,
4904
+
+ "%s",
4905
+
+ self->verify_retry_message);
4906
+
+ } else {
4907
+
+ err = fpi_device_retry_new(self->verify_retry_error);
4908
+
+ }
4909
+
+ fpi_device_verify_report(dev, FPI_MATCH_ERROR, NULL, err);
4910
+
+ self->verify_retry_pending = FALSE;
4911
+
+ self->verify_retry_message[0] = '\0';
4912
+
+ fpi_device_verify_complete(dev, NULL);
4913
+
+ return;
4914
+
+ }
4915
+
+
4916
+
+ if (self->verify_result == FPI_MATCH_ERROR) {
4917
+
+ GError *err = fpi_device_retry_new(FP_DEVICE_RETRY_GENERAL);
4918
+
+ fpi_device_verify_report(dev, FPI_MATCH_ERROR, NULL, err);
4919
+
+ } else {
4920
+
+ fpi_device_verify_report(dev, self->verify_result, NULL, NULL);
4921
+
+ }
4922
+
+ fpi_device_verify_complete(dev, NULL);
4923
+
+ return;
4924
+
+ } else if (action == FPI_DEVICE_ACTION_CAPTURE) {
4925
+
+ if (self->capture_retry_pending) {
4926
+
+ GError *err = NULL;
4927
+
+ if (self->capture_retry_message[0] != '\0') {
4928
+
+ err = fpi_device_retry_new_msg(self->capture_retry_error,
4929
+
+ "%s",
4930
+
+ self->capture_retry_message);
4931
+
+ } else {
4932
+
+ err = fpi_device_retry_new(self->capture_retry_error);
4933
+
+ }
4934
+
+ fpi_device_capture_complete(dev, NULL, err);
4935
+
+ self->capture_retry_pending = FALSE;
4936
+
+ self->capture_retry_message[0] = '\0';
4937
+
+ return;
4938
+
+ }
4939
+
+ /* capture_complete already called in SUBMIT_IMAGE success path. */
4940
+
+ return;
4941
+
+ }
4942
+
+ }
4943
+
+
4944
+
+ fp_dbg("Starting next cycle");
4945
+
+ start_new_cycle(dev);
4946
+
+}
4947
+
+
4948
+
+/*
4949
+
+ * Start a fresh master cycle SSM if the device is active.
4950
+
+ */
4951
+
+static void
4952
+
+start_new_cycle(FpDevice *dev)
4953
+
+{
4954
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
4955
+
+
4956
+
+ if (self->deactivating)
4957
+
+ return;
4958
+
+
4959
+
+ self->cycle_ssm = fpi_ssm_new(dev, cycle_run_state,
4960
+
+ CYCLE_NUM_STATES);
4961
+
+ fpi_ssm_start(self->cycle_ssm, cycle_complete);
4962
+
+}
4963
+
+
4964
+
+/* ============================================================================
4965
+
+ * DEVICE OPERATIONS
4966
+
+ * ============================================================================ */
4967
+
+
4968
+
+/*
4969
+
+ * Open the USB device, claim interface, and initialize driver state.
4970
+
+ */
4971
+
+static void
4972
+
+dev_open(FpDevice *device)
4973
+
+{
4974
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(device);
4975
+
+ GUsbDevice *usb_dev = fpi_device_get_usb_device(device);
4976
+
+ GError *error = NULL;
4977
+
+
4978
+
+ fp_info("Opening CanvasBio CB2000 device");
4979
+
+
4980
+
+ if (!g_usb_device_set_configuration(usb_dev, 1, &error)) {
4981
+
+ fp_dbg("set_configuration: %s (may be OK if already configured)",
4982
+
+ error ? error->message : "unknown");
4983
+
+ g_clear_error(&error);
4984
+
+ }
4985
+
+
4986
+
+ if (!g_usb_device_claim_interface(usb_dev, 0,
4987
+
+ G_USB_DEVICE_CLAIM_INTERFACE_BIND_KERNEL_DRIVER,
4988
+
+ &error)) {
4989
+
+ fp_err("Failed to claim USB interface: %s", error->message);
4990
+
+ fpi_device_open_complete(device, error);
4991
+
+ return;
4992
+
+ }
4993
+
+
4994
+
+ self->image_buffer = g_malloc0(CB2000_IMG_SIZE);
4995
+
+ self->background_buffer = g_malloc0(CB2000_IMG_SIZE);
4996
+
+ self->previous_norm_buffer = g_malloc0(CB2000_IMG_SIZE);
4997
+
+ self->background_valid = FALSE;
4998
+
+ self->previous_norm_valid = FALSE;
4999
+
+ self->deactivating = FALSE;
5000
+
+ self->deactivation_in_progress = FALSE;
5001
+
+ if (self->deactivation_timeout_id > 0) {
5002
+
+ g_source_remove(self->deactivation_timeout_id);
5003
+
+ self->deactivation_timeout_id = 0;
5004
+
+ }
5005
+
+ self->image_offset = 0;
5006
+
+ self->chunks_read = 0;
5007
+
+ self->poll_stable_hits = 0;
5008
+
+ self->no_finger_streak = 0;
5009
+
+ self->removal_poll_count = 0;
5010
+
+ self->removal_stable_off_hits = 0;
5011
+
+ self->poll_total_count = 0;
5012
+
+ self->early_placement_detected = FALSE;
5013
+
+ self->poll_start_us = 0;
5014
+
+ self->removal_start_us = 0;
5015
+
+ self->cycle_ssm = NULL;
5016
+
+ self->settle_timeout_id = 0;
5017
+
+ self->poll_timeout_id = 0;
5018
+
+ self->removal_timeout_id = 0;
5019
+
+ self->early_timeout_id = 0;
5020
+
+ self->force_recovery = FALSE;
5021
+
+ self->retry_total = 0;
5022
+
+ self->accepted_total = 0;
5023
+
+ memset(self->retry_cause_count, 0, sizeof(self->retry_cause_count));
5024
+
+ self->submit_capture_total = 0;
5025
+
+ self->submit_enroll_total = 0;
5026
+
+ self->submit_verify_total = 0;
5027
+
+ self->submit_identify_total = 0;
5028
+
+ self->verify_template_samples = 0;
5029
+
+ self->verify_template_subprints_last = 0;
5030
+
+ self->verify_template_subprints_min = 0;
5031
+
+ self->verify_template_subprints_max = 0;
5032
+
+ self->experimental_device_assisted_verify = FALSE;
5033
+
+ self->verify_cmd_rx_total = 0;
5034
+
+ self->verify_cmd_rx_with_data = 0;
5035
+
+ self->verify_cmd_rx_last_len = 0;
5036
+
+ memset(self->verify_cmd_rx_last, 0, sizeof(self->verify_cmd_rx_last));
5037
+
+ self->finalize_ack1_len = 0;
5038
+
+ self->finalize_ack2_len = 0;
5039
+
+ memset(self->finalize_ack1, 0, sizeof(self->finalize_ack1));
5040
+
+ memset(self->finalize_ack2, 0, sizeof(self->finalize_ack2));
5041
+
+ self->verify_ack_status_last = 0x00;
5042
+
+ self->verify_ack_decision_last = CB2000_VERIFY_ACK_UNKNOWN;
5043
+
+ self->verify_ack_ready_total = 0;
5044
+
+ self->verify_ack_retry_total = 0;
5045
+
+ self->verify_ack_nomatch_total = 0;
5046
+
+ self->verify_ack_unknown_total = 0;
5047
+
+ self->verify_ack_mismatch_total = 0;
5048
+
+ self->verify_status_code_last = 0x00;
5049
+
+ self->verify_result_code_last = 0x00;
5050
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_UNKNOWN;
5051
+
+ self->verify_result_class_last = CB2000_VERIFY_RESULT_CLASS_UNKNOWN;
5052
+
+ memset(self->verify_result_class_count, 0, sizeof(self->verify_result_class_count));
5053
+
+ self->verify_device_status_short_circuit = TRUE;
5054
+
+ self->verify_ready_query_enabled = TRUE;
5055
+
+ self->verify_ready_query_b_enabled = TRUE;
5056
+
+ self->verify_ready_query_total = 0;
5057
+
+ self->verify_ready_query_status_last = 0x00;
5058
+
+ self->verify_ready_query_len = 0;
5059
+
+ memset(self->verify_ready_query_data, 0, sizeof(self->verify_ready_query_data));
5060
+
+ self->verify_ready_query_b_total = 0;
5061
+
+ self->verify_ready_query_b_status_last = 0x00;
5062
+
+ self->verify_ready_query_b_len = 0;
5063
+
+ memset(self->verify_ready_query_b_data, 0, sizeof(self->verify_ready_query_b_data));
5064
+
+ self->verify_ready_query_ready_total = 0;
5065
+
+ self->verify_ready_query_retry_total = 0;
5066
+
+ self->verify_ready_query_nomatch_total = 0;
5067
+
+ self->verify_ready_query_unknown_total = 0;
5068
+
+ self->verify_ready_matrix_last = CB2000_VERIFY_READY_MATRIX_UNKNOWN;
5069
+
+ self->verify_ready_matrix_ready_total = 0;
5070
+
+ self->verify_ready_matrix_retry_total = 0;
5071
+
+ self->verify_ready_matrix_nomatch_total = 0;
5072
+
+ self->verify_ready_matrix_unknown_total = 0;
5073
+
+ self->verify_pre_capture_status_total = 0;
5074
+
+ self->verify_pre_capture_status_len = 0;
5075
+
+ memset(self->verify_pre_capture_status, 0, sizeof(self->verify_pre_capture_status));
5076
+
+ self->verify_retry_pending = FALSE;
5077
+
+ self->verify_retry_error = FP_DEVICE_RETRY_GENERAL;
5078
+
+ self->verify_retry_status_code = 0x00;
5079
+
+ self->verify_retry_result_code = 0x00;
5080
+
+ self->verify_retry_message[0] = '\0';
5081
+
+ self->capture_retry_pending = FALSE;
5082
+
+ self->capture_retry_error = FP_DEVICE_RETRY_GENERAL;
5083
+
+ self->capture_retry_message[0] = '\0';
5084
+
+
5085
+
+ fp_dbg("Device opened successfully");
5086
+
+ fpi_device_open_complete(device, NULL);
5087
+
+}
5088
+
+
5089
+
+/*
5090
+
+ * Release USB interface and free resources.
5091
+
+ */
5092
+
+static void
5093
+
+dev_close(FpDevice *device)
5094
+
+{
5095
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(device);
5096
+
+ GError *error = NULL;
5097
+
+ int i;
5098
+
+
5099
+
+ fp_info("Closing CanvasBio CB2000 device");
5100
+
+
5101
+
+ if (self->settle_timeout_id > 0) {
5102
+
+ g_source_remove(self->settle_timeout_id);
5103
+
+ self->settle_timeout_id = 0;
5104
+
+ }
5105
+
+ if (self->poll_timeout_id > 0) {
5106
+
+ g_source_remove(self->poll_timeout_id);
5107
+
+ self->poll_timeout_id = 0;
5108
+
+ }
5109
+
+ if (self->removal_timeout_id > 0) {
5110
+
+ g_source_remove(self->removal_timeout_id);
5111
+
+ self->removal_timeout_id = 0;
5112
+
+ }
5113
+
+ if (self->early_timeout_id > 0) {
5114
+
+ g_source_remove(self->early_timeout_id);
5115
+
+ self->early_timeout_id = 0;
5116
+
+ }
5117
+
+
5118
+
+ g_clear_pointer(&self->image_buffer, g_free);
5119
+
+ g_clear_pointer(&self->background_buffer, g_free);
5120
+
+ g_clear_pointer(&self->previous_norm_buffer, g_free);
5121
+
+
5122
+
+ for (i = 0; i < 5; i++)
5123
+
+ g_clear_pointer(&self->enroll_images[i], g_free);
5124
+
+
5125
+
+ g_usb_device_release_interface(fpi_device_get_usb_device(device),
5126
+
+ 0, 0, &error);
5127
+
+
5128
+
+ fpi_device_close_complete(device, error);
5129
+
+}
5130
+
+
5131
+
+/*
5132
+
+ * Common initialization shared by all action entry points.
5133
+
+ */
5134
+
+static void
5135
+
+dev_action_common_init(FpiDeviceCanvasbioCb2000 *self)
5136
+
+{
5137
+
+ self->deactivating = FALSE;
5138
+
+ self->deactivation_in_progress = FALSE;
5139
+
+ self->initial_activation_done = FALSE;
5140
+
+ self->force_recovery = FALSE;
5141
+
+ self->previous_norm_valid = FALSE;
5142
+
+ self->retry_total = 0;
5143
+
+ self->accepted_total = 0;
5144
+
+ memset(self->retry_cause_count, 0, sizeof(self->retry_cause_count));
5145
+
+ self->submit_capture_total = 0;
5146
+
+ self->submit_enroll_total = 0;
5147
+
+ self->submit_verify_total = 0;
5148
+
+ self->submit_identify_total = 0;
5149
+
+ self->verify_template_samples = 0;
5150
+
+ self->verify_template_subprints_last = 0;
5151
+
+ self->verify_template_subprints_min = 0;
5152
+
+ self->verify_template_subprints_max = 0;
5153
+
+ self->verify_cmd_rx_total = 0;
5154
+
+ self->verify_cmd_rx_with_data = 0;
5155
+
+ self->verify_cmd_rx_last_len = 0;
5156
+
+ memset(self->verify_cmd_rx_last, 0, sizeof(self->verify_cmd_rx_last));
5157
+
+ self->finalize_ack1_len = 0;
5158
+
+ self->finalize_ack2_len = 0;
5159
+
+ memset(self->finalize_ack1, 0, sizeof(self->finalize_ack1));
5160
+
+ memset(self->finalize_ack2, 0, sizeof(self->finalize_ack2));
5161
+
+ self->verify_ack_status_last = 0x00;
5162
+
+ self->verify_ack_decision_last = CB2000_VERIFY_ACK_UNKNOWN;
5163
+
+ self->verify_ack_ready_total = 0;
5164
+
+ self->verify_ack_retry_total = 0;
5165
+
+ self->verify_ack_nomatch_total = 0;
5166
+
+ self->verify_ack_unknown_total = 0;
5167
+
+ self->verify_ack_mismatch_total = 0;
5168
+
+ self->verify_status_code_last = 0x00;
5169
+
+ self->verify_result_code_last = 0x00;
5170
+
+ self->verify_route_last = CB2000_VERIFY_ROUTE_UNKNOWN;
5171
+
+ self->verify_result_class_last = CB2000_VERIFY_RESULT_CLASS_UNKNOWN;
5172
+
+ memset(self->verify_result_class_count, 0, sizeof(self->verify_result_class_count));
5173
+
+ self->verify_device_status_short_circuit = TRUE;
5174
+
+ self->experimental_device_assisted_verify =
5175
+
+ cb2000_get_env_bool("CB2000_EXPERIMENTAL_DEVICE_ASSISTED_VERIFY", FALSE);
5176
+
+ self->verify_device_status_short_circuit =
5177
+
+ cb2000_get_env_bool("CB2000_VERIFY_DEVICE_STATUS_SHORT_CIRCUIT", TRUE);
5178
+
+ self->verify_ready_query_enabled =
5179
+
+ cb2000_get_env_bool("CB2000_VERIFY_READY_QUERY", TRUE);
5180
+
+ self->verify_ready_query_b_enabled =
5181
+
+ cb2000_get_env_bool("CB2000_VERIFY_READY_QUERY_B", TRUE);
5182
+
+ self->verify_ready_query_total = 0;
5183
+
+ self->verify_ready_query_status_last = 0x00;
5184
+
+ self->verify_ready_query_len = 0;
5185
+
+ memset(self->verify_ready_query_data, 0, sizeof(self->verify_ready_query_data));
5186
+
+ self->verify_ready_query_b_total = 0;
5187
+
+ self->verify_ready_query_b_status_last = 0x00;
5188
+
+ self->verify_ready_query_b_len = 0;
5189
+
+ memset(self->verify_ready_query_b_data, 0, sizeof(self->verify_ready_query_b_data));
5190
+
+ self->verify_ready_query_ready_total = 0;
5191
+
+ self->verify_ready_query_retry_total = 0;
5192
+
+ self->verify_ready_query_nomatch_total = 0;
5193
+
+ self->verify_ready_query_unknown_total = 0;
5194
+
+ self->verify_ready_matrix_last = CB2000_VERIFY_READY_MATRIX_UNKNOWN;
5195
+
+ self->verify_ready_matrix_ready_total = 0;
5196
+
+ self->verify_ready_matrix_retry_total = 0;
5197
+
+ self->verify_ready_matrix_nomatch_total = 0;
5198
+
+ self->verify_ready_matrix_unknown_total = 0;
5199
+
+ self->verify_pre_capture_status_total = 0;
5200
+
+ self->verify_pre_capture_status_len = 0;
5201
+
+ memset(self->verify_pre_capture_status, 0, sizeof(self->verify_pre_capture_status));
5202
+
+ self->verify_retry_pending = FALSE;
5203
+
+ self->verify_retry_error = FP_DEVICE_RETRY_GENERAL;
5204
+
+ self->verify_retry_status_code = 0x00;
5205
+
+ self->verify_retry_result_code = 0x00;
5206
+
+ self->verify_retry_message[0] = '\0';
5207
+
+ self->capture_retry_pending = FALSE;
5208
+
+ self->capture_retry_error = FP_DEVICE_RETRY_GENERAL;
5209
+
+ self->capture_retry_message[0] = '\0';
5210
+
+}
5211
+
+
5212
+
+static void
5213
+
+dev_enroll(FpDevice *device)
5214
+
+{
5215
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(device);
5216
+
+ gint i;
5217
+
+
5218
+
+ fp_info("Starting enrollment (%d stages)", CB2000_NR_ENROLL_STAGES);
5219
+
+ dev_action_common_init(self);
5220
+
+ self->enroll_stage = 0;
5221
+
+ for (i = 0; i < CB2000_NR_ENROLL_STAGES; i++)
5222
+
+ g_clear_pointer(&self->enroll_images[i], g_free);
5223
+
+
5224
+
+ start_new_cycle(device);
5225
+
+}
5226
+
+
5227
+
+static void
5228
+
+dev_verify(FpDevice *device)
5229
+
+{
5230
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(device);
5231
+
+
5232
+
+ fp_info("Starting verification (NCC)");
5233
+
+ dev_action_common_init(self);
5234
+
+ self->verify_result = FPI_MATCH_FAIL;
5235
+
+
5236
+
+ start_new_cycle(device);
5237
+
+}
5238
+
+
5239
+
+static void
5240
+
+dev_capture(FpDevice *device)
5241
+
+{
5242
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(device);
5243
+
+
5244
+
+ fp_info("Starting image capture");
5245
+
+ dev_action_common_init(self);
5246
+
+
5247
+
+ start_new_cycle(device);
5248
+
+}
5249
+
+
5250
+
+/*
5251
+
+ * Deactivation control request completion.
5252
+
+ * In FpDevice mode, this is just a cleanup callback - no deactivate_complete needed.
5253
+
+ */
5254
+
+static void
5255
+
+deactivate_ctrl_cb(FpiUsbTransfer *transfer,
5256
+
+ FpDevice *dev,
5257
+
+ gpointer user_data,
5258
+
+ GError *error)
5259
+
+{
5260
+
+ if (error) {
5261
+
+ fp_warn("Deactivation command error: %s", error->message);
5262
+
+ g_error_free(error);
5263
+
+ }
5264
+
+
5265
+
+ fp_dbg("Deactivation USB command complete");
5266
+
+}
5267
+
+
5268
+
+/*
5269
+
+ * Issue the vendor deactivation control request for cleanup.
5270
+
+ * In FpDevice mode, there is no deactivate_complete to call.
5271
+
+ */
5272
+
+static void
5273
+
+complete_deactivation(FpDevice *dev)
5274
+
+{
5275
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
5276
+
+ FpiUsbTransfer *transfer;
5277
+
+
5278
+
+ if (self->deactivation_in_progress) {
5279
+
+ fp_dbg("Deactivation already in progress, skipping duplicate");
5280
+
+ return;
5281
+
+ }
5282
+
+ self->deactivation_in_progress = TRUE;
5283
+
+ if (self->deactivation_timeout_id > 0) {
5284
+
+ g_source_remove(self->deactivation_timeout_id);
5285
+
+ self->deactivation_timeout_id = 0;
5286
+
+ }
5287
+
+
5288
+
+ fp_dbg("Sending deactivation command (REQ_INIT 0x0001 idx=0)");
5289
+
+
5290
+
+ transfer = fpi_usb_transfer_new(dev);
5291
+
+ fpi_usb_transfer_fill_control(transfer,
5292
+
+ G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
5293
+
+ G_USB_DEVICE_REQUEST_TYPE_VENDOR,
5294
+
+ G_USB_DEVICE_RECIPIENT_DEVICE,
5295
+
+ REQ_INIT, 0x0001, 0, 0);
5296
+
+ fpi_usb_transfer_submit(transfer, CB2000_TIMEOUT, NULL,
5297
+
+ deactivate_ctrl_cb, NULL);
5298
+
+}
5299
+
+
5300
+
+/*
5301
+
+ * Safety timeout: if the cycle is still running after a short delay, force
5302
+
+ * completion to honor cancellation (e.g. Ctrl+C).
5303
+
+ */
5304
+
+static gboolean G_GNUC_UNUSED
5305
+
+deactivation_force_cb(gpointer user_data)
5306
+
+{
5307
+
+ FpDevice *dev = FP_DEVICE(user_data);
5308
+
+ FpiDeviceCanvasbioCb2000 *self = FPI_DEVICE_CANVASBIO_CB2000(dev);
5309
+
+
5310
+
+ self->deactivation_timeout_id = 0;
5311
+
+
5312
+
+ if (!self->deactivating || self->deactivation_in_progress)
5313
+
+ return G_SOURCE_REMOVE;
5314
+
+
5315
+
+ if (self->cycle_ssm) {
5316
+
+ /* Still busy: force completion to honor cancel/ctrl+c */
5317
+
+ fpi_ssm_mark_completed(self->cycle_ssm);
5318
+
+ } else {
5319
+
+ complete_deactivation(dev);
5320
+
+ }
5321
+
+
5322
+
+ return G_SOURCE_REMOVE;
5323
+
+}
5324
+
+
5325
+
+/* ============================================================================
5326
+
+ * DRIVER REGISTRATION
5327
+
+ * ============================================================================ */
5328
+
+
5329
+
+static const FpIdEntry id_table[] = {
5330
+
+ { .vid = CB2000_VID, .pid = CB2000_PID_1 },
5331
+
+ { .vid = CB2000_VID, .pid = CB2000_PID_2 },
5332
+
+ { .vid = 0, .pid = 0 },
5333
+
+};
5334
+
+
5335
+
+static void
5336
+
+fpi_device_canvasbio_cb2000_init(FpiDeviceCanvasbioCb2000 *self)
5337
+
+{
5338
+
+}
5339
+
+
5340
+
+static void
5341
+
+fpi_device_canvasbio_cb2000_class_init(FpiDeviceCanvasbioCb2000Class *klass)
5342
+
+{
5343
+
+ FpDeviceClass *dev_class = FP_DEVICE_CLASS(klass);
5344
+
+
5345
+
+ dev_class->id = "canvasbio-cb2000";
5346
+
+ dev_class->full_name = "CanvasBio CB2000";
5347
+
+ dev_class->type = FP_DEVICE_TYPE_USB;
5348
+
+ dev_class->id_table = id_table;
5349
+
+ dev_class->scan_type = FP_SCAN_TYPE_PRESS;
5350
+
+
5351
+
+ dev_class->open = dev_open;
5352
+
+ dev_class->close = dev_close;
5353
+
+ dev_class->enroll = dev_enroll;
5354
+
+ dev_class->verify = dev_verify;
5355
+
+ dev_class->capture = dev_capture;
5356
+
+ dev_class->nr_enroll_stages = CB2000_NR_ENROLL_STAGES;
5357
+
+
5358
+
+ fpi_device_class_auto_initialize_features(dev_class);
5359
+
+}
5360
+
diff --git a/libfprint/drivers/meson.build b/libfprint/drivers/meson.build
5361
+
new file mode 100644
5362
+
index 0000000..cfad60d
5363
+
--- /dev/null
5364
+
+++ b/libfprint/drivers/meson.build
5365
+
@@ -0,0 +1,13 @@
5366
+
+# CanvasBio CB2000 driver for libfprint
5367
+
+#
5368
+
+# To integrate with libfprint:
5369
+
+# 1. Copy this folder to libfprint/libfprint/drivers/canvasbio_cb2000/
5370
+
+# 2. Add 'canvasbio_cb2000' to driver_sources dict in libfprint/libfprint/meson.build
5371
+
+# 3. Add 'canvasbio_cb2000' to default_drivers list in libfprint/meson.build
5372
+
+# 4. Rebuild libfprint
5373
+
+#
5374
+
+# IMPORTANT: Use underscore (_) not hyphen (-) in driver name!
5375
+
+
5376
+
+canvasbio_cb2000_sources = files(
5377
+
+ 'canvasbio_cb2000.c',
5378
+
+)
5379
+
\ No newline at end of file
5380
+
diff --git a/libfprint/meson.build b/libfprint/meson.build
5381
+
index ae0f6e2..5dbe9a4 100644
5382
+
--- a/libfprint/meson.build
5383
+
+++ b/libfprint/meson.build
5384
+
@@ -87,6 +87,8 @@ nbis_sources = [
5385
+
]
5386
+
5387
+
driver_sources = {
5388
+
+ 'canvasbio_cb2000' :
5389
+
+ [ 'drivers/canvasbio_cb2000.c' ],
5390
+
'upekts' :
5391
+
[ 'drivers/upekts.c', 'drivers/upek_proto.c' ],
5392
+
'upektc' :
5393
+
diff --git a/meson.build b/meson.build
5394
+
index 14fb11f..6fd1820 100644
5395
+
--- a/meson.build
5396
+
+++ b/meson.build
5397
+
@@ -115,6 +115,7 @@ virtual_drivers = [
5398
+
]
5399
+
5400
+
default_drivers = [
5401
+
+ 'canvasbio_cb2000',
5402
+
'upektc_img',
5403
+
'vfs5011',
5404
+
'vfs7552',
5405
+
diff --git a/tests/meson.build b/tests/meson.build
5406
+
index 07c924b..395c5d9 100644
5407
+
--- a/tests/meson.build
5408
+
+++ b/tests/meson.build
5409
+
@@ -321,16 +321,6 @@ foreach test_name: unit_tests
5410
+
)
5411
+
endforeach
5412
+
5413
+
-# Run udev rule generator with fatal warnings
5414
+
-envs.set('UDEV_HWDB', udev_hwdb.full_path())
5415
+
-envs.set('UDEV_HWDB_CHECK_CONTENTS', default_drivers_are_enabled ? '1' : '0')
5416
+
-envs.set('G_MESSAGES_DEBUG', '')
5417
+
-test('udev-hwdb',
5418
+
- find_program('test-generated-hwdb.sh'),
5419
+
- depends: udev_hwdb,
5420
+
- suite: ['data', 'no-valgrind'],
5421
+
- env: envs)
5422
+
-
5423
+
appstreamcli = find_program('appstreamcli', required: false)
5424
+
if appstreamcli.found()
5425
+
test('metainfo-validate',