fp_internal.h 9.28 KB
Newer Older
1 2
/*
 * Internal/private definitions for libfprint
3
 * Copyright (C) 2007-2008 Daniel Drake <dsd@gentoo.org>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef __FPRINT_INTERNAL_H__
#define __FPRINT_INTERNAL_H__

Daniel Drake's avatar
Daniel Drake committed
23
#include <config.h>
24

25
#include <stdint.h>
26
#include <errno.h>
Daniel Drake's avatar
Daniel Drake committed
27
#include <glib.h>
28
#include <libusb.h>
29

30
#include "fprint.h"
31
#include "fpi-log.h"
32
#include "fpi-dev.h"
33
#include "drivers/driver_ids.h"
34

35 36 37 38
#define container_of(ptr, type, member) ({                      \
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
        (type *)( (char *)__mptr - offsetof(type,member) );})

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
enum fp_dev_state {
	DEV_STATE_INITIAL = 0,
	DEV_STATE_ERROR,
	DEV_STATE_INITIALIZING,
	DEV_STATE_INITIALIZED,
	DEV_STATE_DEINITIALIZING,
	DEV_STATE_DEINITIALIZED,
	DEV_STATE_ENROLL_STARTING,
	DEV_STATE_ENROLLING,
	DEV_STATE_ENROLL_STOPPING,
	DEV_STATE_VERIFY_STARTING,
	DEV_STATE_VERIFYING,
	DEV_STATE_VERIFY_DONE,
	DEV_STATE_VERIFY_STOPPING,
	DEV_STATE_IDENTIFY_STARTING,
	DEV_STATE_IDENTIFYING,
	DEV_STATE_IDENTIFY_DONE,
	DEV_STATE_IDENTIFY_STOPPING,
57 58 59 60
	DEV_STATE_CAPTURE_STARTING,
	DEV_STATE_CAPTURING,
	DEV_STATE_CAPTURE_DONE,
	DEV_STATE_CAPTURE_STOPPING,
61 62
};

63 64
struct fp_driver **fprint_get_drivers (void);

65
struct fp_dev {
66
	struct fp_driver *drv;
67
	libusb_device_handle *udev;
68
	uint32_t devtype;
69
	void *priv;
Daniel Drake's avatar
Daniel Drake committed
70

71 72 73
	/* only valid if drv->type == DRIVER_IMAGING */
	struct fp_img_dev *img_dev;

Daniel Drake's avatar
Daniel Drake committed
74
	int nr_enroll_stages;
Daniel Drake's avatar
Daniel Drake committed
75

76 77 78 79 80
	/* read-only to drivers */
	struct fp_print_data *verify_data;

	/* drivers should not mess with any of the below */
	enum fp_dev_state state;
Daniel Drake's avatar
Daniel Drake committed
81
	int __enroll_stage;
82
	int unconditional_capture;
83 84 85 86 87

	/* async I/O callbacks and data */
	/* FIXME: convert this to generic state operational data mechanism? */
	fp_dev_open_cb open_cb;
	void *open_cb_data;
88
	fp_operation_stop_cb close_cb;
89 90 91
	void *close_cb_data;
	fp_enroll_stage_cb enroll_stage_cb;
	void *enroll_stage_cb_data;
92
	fp_operation_stop_cb enroll_stop_cb;
93
	void *enroll_stop_cb_data;
94
	fp_img_operation_cb verify_cb;
95
	void *verify_cb_data;
96
	fp_operation_stop_cb verify_stop_cb;
97
	void *verify_stop_cb_data;
98
	fp_identify_cb identify_cb;
99
	void *identify_cb_data;
100
	fp_operation_stop_cb identify_stop_cb;
101
	void *identify_stop_cb_data;
102
	fp_img_operation_cb capture_cb;
103
	void *capture_cb_data;
104
	fp_operation_stop_cb capture_stop_cb;
105
	void *capture_stop_cb_data;
106 107 108

	/* FIXME: better place to put this? */
	struct fp_print_data **identify_gallery;
109 110
};

111 112 113 114 115 116 117 118 119 120 121 122
enum fp_imgdev_state {
	IMGDEV_STATE_INACTIVE,
	IMGDEV_STATE_AWAIT_FINGER_ON,
	IMGDEV_STATE_CAPTURE,
	IMGDEV_STATE_AWAIT_FINGER_OFF,
};

enum fp_imgdev_action {
	IMG_ACTION_NONE = 0,
	IMG_ACTION_ENROLL,
	IMG_ACTION_VERIFY,
	IMG_ACTION_IDENTIFY,
123
	IMG_ACTION_CAPTURE,
124 125 126 127 128 129 130 131 132 133 134 135 136 137
};

enum fp_imgdev_enroll_state {
	IMG_ACQUIRE_STATE_NONE = 0,
	IMG_ACQUIRE_STATE_ACTIVATING,
	IMG_ACQUIRE_STATE_AWAIT_FINGER_ON,
	IMG_ACQUIRE_STATE_AWAIT_IMAGE,
	IMG_ACQUIRE_STATE_AWAIT_FINGER_OFF,
	IMG_ACQUIRE_STATE_DONE,
	IMG_ACQUIRE_STATE_DEACTIVATING,
};

enum fp_imgdev_verify_state {
	IMG_VERIFY_STATE_NONE = 0,
138
	IMG_VERIFY_STATE_ACTIVATING
139 140
};

141
struct fp_img_dev {
142 143
	struct fp_dev *parent;

144 145 146 147
	enum fp_imgdev_action action;
	int action_state;

	struct fp_print_data *acquire_data;
148
	struct fp_print_data *enroll_data;
149
	struct fp_img *acquire_img;
150
	int enroll_stage;
151 152 153 154 155
	int action_result;

	/* FIXME: better place to put this? */
	size_t identify_match_offset;

156 157 158
	void *priv;
};

159 160 161
int fpi_imgdev_get_img_width(struct fp_img_dev *imgdev);
int fpi_imgdev_get_img_height(struct fp_img_dev *imgdev);

162 163 164 165 166 167
struct usb_id {
	uint16_t vendor;
	uint16_t product;
	unsigned long driver_data;
};

168 169 170 171 172
enum fp_driver_type {
	DRIVER_PRIMITIVE = 0,
	DRIVER_IMAGING = 1,
};

173
struct fp_driver {
174
	const uint16_t id;
175 176 177
	const char *name;
	const char *full_name;
	const struct usb_id * const id_table;
178
	enum fp_driver_type type;
179
	enum fp_scan_type scan_type;
180 181

	void *priv;
182 183

	/* Device operations */
184
	int (*discover)(struct libusb_device_descriptor *dsc, uint32_t *devtype);
185 186
	int (*open)(struct fp_dev *dev, unsigned long driver_data);
	void (*close)(struct fp_dev *dev);
187 188 189 190 191 192
	int (*enroll_start)(struct fp_dev *dev);
	int (*enroll_stop)(struct fp_dev *dev);
	int (*verify_start)(struct fp_dev *dev);
	int (*verify_stop)(struct fp_dev *dev, gboolean iterating);
	int (*identify_start)(struct fp_dev *dev);
	int (*identify_stop)(struct fp_dev *dev, gboolean iterating);
193 194
	int (*capture_start)(struct fp_dev *dev);
	int (*capture_stop)(struct fp_dev *dev);
195 196
};

Daniel Drake's avatar
Daniel Drake committed
197 198
enum fp_print_data_type fpi_driver_get_data_type(struct fp_driver *drv);

199 200 201
/* flags for fp_img_driver.flags */
#define FP_IMGDRV_SUPPORTS_UNCONDITIONAL_CAPTURE (1 << 0)

202 203
struct fp_img_driver {
	struct fp_driver driver;
204
	uint16_t flags;
205 206
	int img_width;
	int img_height;
207
	int bz3_threshold;
208 209

	/* Device operations */
210 211
	int (*open)(struct fp_img_dev *dev, unsigned long driver_data);
	void (*close)(struct fp_img_dev *dev);
212 213 214
	int (*activate)(struct fp_img_dev *dev, enum fp_imgdev_state state);
	int (*change_state)(struct fp_img_dev *dev, enum fp_imgdev_state state);
	void (*deactivate)(struct fp_img_dev *dev);
215 216
};

217
#include "drivers_definitions.h"
218

Daniel Drake's avatar
Daniel Drake committed
219
extern libusb_context *fpi_usb_ctx;
220 221
extern GSList *opened_devices;

222
void fpi_img_driver_setup(struct fp_img_driver *idriver);
223

224 225 226
#define fpi_driver_to_img_driver(drv) \
	container_of((drv), struct fp_img_driver, driver)

227
struct fp_dscv_dev {
228
	struct libusb_device *udev;
229
	struct fp_driver *drv;
230
	unsigned long driver_data;
231
	uint32_t devtype;
232 233
};

Daniel Drake's avatar
Daniel Drake committed
234 235 236 237 238 239 240
struct fp_dscv_print {
	uint16_t driver_id;
	uint32_t devtype;
	enum fp_finger finger;
	char *path;
};

241 242 243 244 245
enum fp_print_data_type {
	PRINT_DATA_RAW = 0, /* memset-imposed default */
	PRINT_DATA_NBIS_MINUTIAE,
};

246 247 248 249 250
struct fp_print_data_item {
	size_t length;
	unsigned char data[0];
};

251
struct fp_print_data {
252 253 254
	uint16_t driver_id;
	uint32_t devtype;
	enum fp_print_data_type type;
255
	GSList *prints;
256 257
};

258
struct fpi_print_data_fp2 {
259 260 261 262 263 264 265
	char prefix[3];
	uint16_t driver_id;
	uint32_t devtype;
	unsigned char data_type;
	unsigned char data[0];
} __attribute__((__packed__));

266 267 268 269 270
struct fpi_print_data_item_fp2 {
	uint32_t length;
	unsigned char data[0];
} __attribute__((__packed__));

271
void fpi_data_exit(void);
272 273
struct fp_print_data *fpi_print_data_new(struct fp_dev *dev);
struct fp_print_data_item *fpi_print_data_item_new(size_t length);
Daniel Drake's avatar
Daniel Drake committed
274 275 276
gboolean fpi_print_data_compatible(uint16_t driver_id1, uint32_t devtype1,
	enum fp_print_data_type type1, uint16_t driver_id2, uint32_t devtype2,
	enum fp_print_data_type type2);
277

278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
struct fp_minutia {
	int x;
	int y;
	int ex;
	int ey;
	int direction;
	double reliability;
	int type;
	int appearing;
	int feature_id;
	int *nbrs;
	int *ridge_counts;
	int num_nbrs;
};

293 294 295 296 297 298
struct fp_minutiae {
	int alloc;
	int num;
	struct fp_minutia **list;
};

Daniel Drake's avatar
Daniel Drake committed
299
/* bit values for fp_img.flags */
300 301
#define FP_IMG_V_FLIPPED	(1<<0)
#define FP_IMG_H_FLIPPED	(1<<1)
Daniel Drake's avatar
Daniel Drake committed
302
#define FP_IMG_COLORS_INVERTED	(1<<2)
303
#define FP_IMG_BINARIZED_FORM	(1<<3)
304
#define FP_IMG_PARTIAL		(1<<4)
305 306 307

#define FP_IMG_STANDARDIZATION_FLAGS (FP_IMG_V_FLIPPED | FP_IMG_H_FLIPPED \
	| FP_IMG_COLORS_INVERTED)
Daniel Drake's avatar
Daniel Drake committed
308

309 310 311 312
struct fp_img {
	int width;
	int height;
	size_t length;
Daniel Drake's avatar
Daniel Drake committed
313
	uint16_t flags;
314 315
	struct fp_minutiae *minutiae;
	unsigned char *binarized;
316 317 318 319 320 321
	unsigned char data[0];
};

struct fp_img *fpi_img_new(size_t length);
struct fp_img *fpi_img_resize(struct fp_img *img, size_t newsize);
gboolean fpi_img_is_sane(struct fp_img *img);
322
int fpi_img_to_print_data(struct fp_img_dev *imgdev, struct fp_img *img,
323
	struct fp_print_data **ret);
324 325
int fpi_img_compare_print_data(struct fp_print_data *enrolled_print,
	struct fp_print_data *new_print);
326
int fpi_img_compare_print_data_to_gallery(struct fp_print_data *print,
327
	struct fp_print_data **gallery, int match_threshold, size_t *match_offset);
328
struct fp_img *fpi_im_resize(struct fp_img *img, unsigned int w_factor, unsigned int h_factor);
329

330
/* polling */
331

Daniel Drake's avatar
Daniel Drake committed
332
void fpi_poll_init(void);
333 334
void fpi_poll_exit(void);

335 336
void fpi_drvcb_open_complete(struct fp_dev *dev, int status);
void fpi_drvcb_close_complete(struct fp_dev *dev);
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352

void fpi_drvcb_enroll_started(struct fp_dev *dev, int status);
void fpi_drvcb_enroll_stage_completed(struct fp_dev *dev, int result,
	struct fp_print_data *data, struct fp_img *img);
void fpi_drvcb_enroll_stopped(struct fp_dev *dev);

void fpi_drvcb_verify_started(struct fp_dev *dev, int status);
void fpi_drvcb_report_verify_result(struct fp_dev *dev, int result,
	struct fp_img *img);
void fpi_drvcb_verify_stopped(struct fp_dev *dev);

void fpi_drvcb_identify_started(struct fp_dev *dev, int status);
void fpi_drvcb_report_identify_result(struct fp_dev *dev, int result,
	size_t match_offset, struct fp_img *img);
void fpi_drvcb_identify_stopped(struct fp_dev *dev);

353 354 355 356 357
void fpi_drvcb_capture_started(struct fp_dev *dev, int status);
void fpi_drvcb_report_capture_result(struct fp_dev *dev, int result,
	struct fp_img *img);
void fpi_drvcb_capture_stopped(struct fp_dev *dev);

358 359
#endif