rpms/libfprint
6
0
Fork 0
Code Issues Pull Requests Releases Activity

* Thu Aug 19 2010 Bastien Nocera <bnocera@redhat.com> 0.2.0-1

Browse Source 
- Update to 0.2.0
This commit is contained in:
Bastien Nocera 2010-08-19 17:11:28 +01:00
parent c905bbe653
commit a7b0116497
6 changed files with 8 additions and 2177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
0001-Add-gdk-pixbuf-support.patch
View File

@ -1,228 +0,0 @@
From 2028670e54184aa57a30b7b800ae19671db5deb9 Mon Sep 17 00:00:00 2001
From: Bastien Nocera <hadess@hadess.net>
Date: Wed, 29 Oct 2008 12:53:24 +0000
Subject: [PATCH] Add gdk-pixbuf support
When imaging support is required, we prefer to use gdk-pixbuf,
as it's already on things like Live CDs.
Also fix the examples building against the system libfprint.
---
configure.ac | 30 ++++++++++++----
examples/Makefile.am | 10 +++---
libfprint/Makefile.am | 10 ++++-
libfprint/gdkpixbuf.c | 88 +++++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 123 insertions(+), 15 deletions(-)
create mode 100644 libfprint/gdkpixbuf.c
diff --git a/configure.ac b/configure.ac
index d77340f..b3942ff 100644
--- a/configure.ac
+++ b/configure.ac
@@ -20,7 +20,7 @@ AC_SUBST(lt_age)
all_drivers="upekts upektc upeksonly vcom5s uru4000 fdu2000 aes1610 aes2501 aes4000"
-require_imagemagick='no'
+require_imaging='no'
require_aeslib='no'
enable_upekts='no'
enable_upektc='no'
@@ -76,7 +76,7 @@ for driver in `echo ${drivers} | sed -e 's/,/ /g' -e 's/,$//g'`; do
aes4000)
AC_DEFINE([ENABLE_AES4000], [], [Build AuthenTec AES4000 driver])
require_aeslib="yes"
- require_imagemagick="yes"
+ require_imaging="yes"
enable_aes4000="yes"
;;
esac
@@ -91,7 +91,6 @@ AM_CONDITIONAL([ENABLE_URU4000], [test "$enable_uru4000" != "no"])
#AM_CONDITIONAL([ENABLE_AES1610], [test "$enable_aes1610" != "no"])
AM_CONDITIONAL([ENABLE_AES2501], [test "$enable_aes2501" != "no"])
AM_CONDITIONAL([ENABLE_AES4000], [test "$enable_aes4000" != "no"])
-AM_CONDITIONAL([REQUIRE_IMAGEMAGICK], [test "$require_imagemagick" != "no"])
AM_CONDITIONAL([REQUIRE_AESLIB], [test "$require_aeslib" != "no"])
@@ -108,11 +107,26 @@ PKG_CHECK_MODULES(GLIB, "glib-2.0")
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
-if test "$require_imagemagick" != "no"; then
-PKG_CHECK_MODULES(IMAGEMAGICK, "ImageMagick")
-AC_SUBST(IMAGEMAGICK_CFLAGS)
-AC_SUBST(IMAGEMAGICK_LIBS)
-fi;
+imagemagick_found=no
+gdkpixbuf_found=no
+
+if test "$require_imaging" != "no"; then
+ PKG_CHECK_MODULES(IMAGING, gthread-2.0 gdk-pixbuf-2.0, [gdkpixbuf_found=yes], [gdkpixbuf_found=no])
+ if test "$gdkpixbuf_found" != "yes"; then
+ PKG_CHECK_MODULES(IMAGING, ImageMagick, [imagemagick_found=yes], [imagemagick_found=no])
+ fi
+fi
+
+if test "$require_imaging" != "no"; then
+ if test "$gdkpixbuf_found" != "yes" && test "$imagemagick_found" != "yes"; then
+ AC_MSG_ERROR([gdk-pixbuf or ImageMagick is required for imaging support])
+ fi
+fi
+
+AM_CONDITIONAL([REQUIRE_GDKPIXBUF], [test "$gdkpixbuf_found" != "no"])
+AM_CONDITIONAL([REQUIRE_IMAGEMAGICK], [test "$imagemagick_found" != "no"])
+AC_SUBST(IMAGING_CFLAGS)
+AC_SUBST(IMAGING_LIBS)
# Examples build
AC_ARG_ENABLE([examples-build], [AS_HELP_STRING([--enable-examples-build],
diff --git a/examples/Makefile.am b/examples/Makefile.am
index eb6dedb..3f89134 100644
--- a/examples/Makefile.am
+++ b/examples/Makefile.am
@@ -2,22 +2,22 @@ INCLUDES = -I$(top_srcdir)
noinst_PROGRAMS = verify_live enroll verify img_capture
verify_live_SOURCES = verify_live.c
-verify_live_LDADD = ../libfprint/libfprint.la -lfprint
+verify_live_LDADD = ../libfprint/libfprint.la
enroll_SOURCES = enroll.c
-enroll_LDADD = ../libfprint/libfprint.la -lfprint
+enroll_LDADD = ../libfprint/libfprint.la
verify_SOURCES = verify.c
-verify_LDADD = ../libfprint/libfprint.la -lfprint
+verify_LDADD = ../libfprint/libfprint.la
img_capture_SOURCES = img_capture.c
-img_capture_LDADD = ../libfprint/libfprint.la -lfprint
+img_capture_LDADD = ../libfprint/libfprint.la
if BUILD_X11_EXAMPLES
noinst_PROGRAMS += img_capture_continuous
img_capture_continuous_CFLAGS = $(X_CFLAGS) $(XV_CFLAGS)
img_capture_continuous_SOURCES = img_capture_continuous.c
-img_capture_continuous_LDADD = ../libfprint/libfprint.la -lfprint $(X_LIBS) $(X_PRE_LIBS) $(XV_LIBS) -lX11 $(X_EXTRA_LIBS);
+img_capture_continuous_LDADD = ../libfprint/libfprint.la $(X_LIBS) $(X_PRE_LIBS) $(XV_LIBS) -lX11 $(X_EXTRA_LIBS);
endif
diff --git a/libfprint/Makefile.am b/libfprint/Makefile.am
index 844b09e..0ffa0f6 100644
--- a/libfprint/Makefile.am
+++ b/libfprint/Makefile.am
@@ -92,8 +92,14 @@ endif
if REQUIRE_IMAGEMAGICK
OTHER_SRC += imagemagick.c
-libfprint_la_CFLAGS += $(IMAGEMAGICK_CFLAGS)
-libfprint_la_LIBADD += $(IMAGEMAGICK_LIBS)
+libfprint_la_CFLAGS += $(IMAGING_CFLAGS)
+libfprint_la_LIBADD += $(IMAGING_LIBS)
+endif
+
+if REQUIRE_GDKPIXBUF
+OTHER_SRC += gdkpixbuf.c
+libfprint_la_CFLAGS += $(IMAGING_CFLAGS)
+libfprint_la_LIBADD += $(IMAGING_LIBS)
endif
if REQUIRE_AESLIB
diff --git a/libfprint/gdkpixbuf.c b/libfprint/gdkpixbuf.c
new file mode 100644
index 0000000..7ffc099
--- /dev/null
+++ b/libfprint/gdkpixbuf.c
@@ -0,0 +1,88 @@
+/*
+ * Imaging utility functions for libfprint
+ * Copyright (C) 2007-2008 Daniel Drake <dsd@gentoo.org>
+ *
+ * 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
+ */
+
+#include <errno.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "fp_internal.h"
+
+struct fp_img *fpi_im_resize(struct fp_img *img, unsigned int factor)
+{
+ int new_width = img->width * factor;
+ int new_height = img->height * factor;
+ GdkPixbuf *orig, *resized;
+ struct fp_img *newimg;
+ guchar *pixels;
+ guint y;
+ int rowstride;
+
+ g_type_init ();
+
+ /* It is possible to implement resizing using a simple algorithm, however
+ * we use gdk-pixbuf because it applies some kind of smoothing to the
+ * result, which improves matching performances in my experiments. */
+
+ /* Create the original pixbuf, and fill it in from the grayscale data */
+ orig = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+ FALSE,
+ 8,
+ img->width,
+ img->height);
+ rowstride = gdk_pixbuf_get_rowstride (orig);
+ pixels = gdk_pixbuf_get_pixels (orig);
+ for (y = 0; y < img->height; y++) {
+ guint x;
+ for (x = 0; x < img->width; x++) {
+ guchar *p, *r;
+
+ p = pixels + y * rowstride + x * 3;
+ r = img->data + y * img->width + x;
+ p[0] = r[0];
+ p[1] = r[0];
+ p[2] = r[0];
+ }
+ }
+
+ /* Resize the pixbuf, and create the new fp_img */
+ resized = gdk_pixbuf_scale_simple (orig, new_width, new_height, GDK_INTERP_HYPER);
+ g_object_unref (orig);
+
+ newimg = fpi_img_new(new_width * new_height);
+ newimg->width = new_width;
+ newimg->height = new_height;
+ newimg->flags = img->flags;
+
+ rowstride = gdk_pixbuf_get_rowstride (resized);
+ pixels = gdk_pixbuf_get_pixels (resized);
+ for (y = 0; y < newimg->height; y++) {
+ guint x;
+ for (x = 0; x < newimg->width; x++) {
+ guchar *p, *r;
+
+ r = img->data + y * img->width + x;
+ p = pixels + y * rowstride + x * 3;
+ r[0] = p[0];
+ }
+ }
+
+ g_object_unref (resized);
+
+ return newimg;
+}
+
--
1.6.0.3

126
0001-Add-udev-rules-to-set-devices-to-autosuspend.patch
View File

@ -1,126 +0,0 @@
From c60d18b9e5e7d62c27d29d4f386a296edc3c491d Mon Sep 17 00:00:00 2001
From: Matthew Garrett <mjg@redhat.com>
Date: Thu, 1 Oct 2009 15:08:41 +0100
Subject: [PATCH] Add udev rules to set devices to autosuspend
Most fingerprint readers can be suspended safely, so use
the udev rules to autosuspend them when they appear.
The script itself contains whitelists and blacklists.
---
libfprint/Makefile.am | 13 +++++-
libfprint/fprint-list-udev-rules.c | 73 ++++++++++++++++++++++++++++++++++++
2 files changed, 84 insertions(+), 2 deletions(-)
create mode 100644 libfprint/fprint-list-udev-rules.c
diff --git a/libfprint/Makefile.am b/libfprint/Makefile.am
index 0eb5ca6..7f05468 100644
--- a/libfprint/Makefile.am
+++ b/libfprint/Makefile.am
@@ -1,6 +1,6 @@
lib_LTLIBRARIES = libfprint.la
-noinst_PROGRAMS = fprint-list-hal-info
-MOSTLYCLEANFILES = $(hal_fdi_DATA)
+noinst_PROGRAMS = fprint-list-hal-info fprint-list-udev-rules
+MOSTLYCLEANFILES = $(hal_fdi_DATA) $(udev_rules_DATA)
UPEKTS_SRC = drivers/upekts.c
UPEKTC_SRC = drivers/upektc.c
@@ -66,6 +66,15 @@ hal_fdidir = $(datadir)/hal/fdi/information/20thirdparty/
$(hal_fdi_DATA): fprint-list-hal-info
$(builddir)/fprint-list-hal-info > $@
+fprint_list_udev_rules_SOURCES = fprint-list-udev-rules.c
+fprint_list_udev_rules_CFLAGS = -fvisibility=hidden -I$(srcdir)/nbis/include $(LIBUSB_CFLAGS) $(GLIB_CFLAGS) $(IMAGEMAGICK_CFLAGS) $(CRYPTO_CFLAGS) $(AM_CFLAGS)
+fprint_list_udev_rules_LDADD = $(builddir)/libfprint.la
+
+udev_rules_DATA = 60-fprint-autosuspend.rules
+udev_rulesdir = $(sysconfdir)/udev/rules.d/
+
+$(udev_rules_DATA): fprint-list-udev-rules
+ $(builddir)/fprint-list-udev-rules > $@
if ENABLE_UPEKTS
DRIVER_SRC += $(UPEKTS_SRC)
diff --git a/libfprint/fprint-list-udev-rules.c b/libfprint/fprint-list-udev-rules.c
new file mode 100644
index 0000000..874e41a
--- /dev/null
+++ b/libfprint/fprint-list-udev-rules.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2009 Red Hat <mjg@redhat.com>
+ * Copyright (C) 2008 Bastien Nocera <hadess@hadess.net>
+ * Copyright (C) 2008 Timo Hoenig <thoenig@suse.de>, <thoenig@nouse.net>
+ *
+ * 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
+ */
+
+#include <config.h>
+#include <stdio.h>
+
+#include "fp_internal.h"
+
+static const struct usb_id whitelist_id_table[] = {
+ { .vendor = 0x08ff, .product = 0x2810 },
+ { 0, 0, 0, },
+};
+
+static const struct usb_id blacklist_id_table[] = {
+ { .vendor = 0x0483, .product = 0x2016 },
+ { 0, 0, 0 },
+};
+
+struct fp_driver whitelist = {
+ .id_table = whitelist_id_table,
+};
+
+static void print_driver (struct fp_driver *driver)
+{
+ int i, j, blacklist;
+
+ for (i = 0; driver->id_table[i].vendor != 0; i++) {
+ blacklist = 0;
+ for (j = 0; blacklist_id_table[j].vendor != 0; j++) {
+ if (driver->id_table[i].vendor == blacklist_id_table[j].vendor &&
+ driver->id_table[j].product == blacklist_id_table[j].product) {
+ blacklist = 1;
+ }
+ }
+ if (blacklist)
+ continue;
+
+ printf ("SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"%04x\", ATTRS{idProduct}==\"%04x\", ATTRS{dev}==\"*\", ATTR{power/level}=\"auto\"\n", driver->id_table[i].vendor, driver->id_table[i].product);
+ }
+}
+
+int main (int argc, char **argv)
+{
+ struct fp_driver **list;
+ guint i;
+
+ list = fprint_get_drivers ();
+
+ for (i = 0; list[i] != NULL; i++) {
+ print_driver (list[i]);
+ }
+
+ print_driver (&whitelist);
+
+ return 0;
+}
--
1.6.4.4

552
aes1610.c
View File

@ -1,552 +0,0 @@
/*
* AuthenTec AES1610 driver for libfprint
* Copyright (C) 2007 Anthony Bretaudeau <wxcover@users.sourceforge.net>
* Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
* Copyright (C) 2007 Cyrille Bagard
* Copyright (C) 2007 Vasily Khoruzhick
*
* Based on code from http://home.gna.org/aes2501, relicensed with permission
*
* 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
*/
#define FP_COMPONENT "aes1610"
#include <errno.h>
#include <string.h>
#include <libusb.h>
#include <aeslib.h>
#include <fp_internal.h>
/* FIXME these need checking */
#define EP_IN (1 | LIBUSB_ENDPOINT_IN)
#define EP_OUT (2 | LIBUSB_ENDPOINT_OUT)
#define BULK_TIMEOUT 4000
#define FIRST_AES1610_REG 0x1B
#define LAST_AES1610_REG 0xFF
/*
* The AES1610 is an imaging device using a swipe-type sensor. It samples
* the finger at preprogrammed intervals, sending a 128x8 frame to the
* computer.
* Unless the user is scanning their finger unreasonably fast, the frames
* *will* overlap. The implementation below detects this overlap and produces
* a contiguous image as the end result.
* The fact that the user determines the length of the swipe (and hence the
* number of useful frames) and also the fact that overlap varies means that
* images returned from this driver vary in height.
*/
#define FRAME_WIDTH 128
#define FRAME_HEIGHT 8
#define FRAME_SIZE (FRAME_WIDTH * FRAME_HEIGHT)
/* maximum number of frames to read during a scan */
/* FIXME reduce substantially */
#define MAX_FRAMES 350
static int read_data(struct fp_img_dev *dev, unsigned char *data, size_t len)
{
int r;
int transferred;
struct libusb_bulk_transfer msg = {
.endpoint = EP_IN,
.data = data,
.length = len,
};
fp_dbg("len=%zd", len);
r = libusb_bulk_transfer(dev->udev, &msg, &transferred, BULK_TIMEOUT);
if (r < 0) {
fp_err("bulk read error %d", r);
return r;
} else if (transferred < len) {
fp_err("unexpected short read %d/%zd", r, len);
return -EIO;
}
return 0;
}
static const struct aes_regwrite init[] = {
{ 0x82, 0x00 }
};
static const struct aes_regwrite stop_reader[] = {
{ 0xFF, 0x00 }
};
static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
{
int r;
r = libusb_claim_interface(dev->udev, 0);
if (r < 0) {
fp_err("could not claim interface 0");
return r;
}
/* FIXME check endpoints */
return aes_write_regv(dev, init, G_N_ELEMENTS(init));
}
static int do_exit(struct fp_img_dev *dev)
{
return aes_write_regv(dev, stop_reader, G_N_ELEMENTS(stop_reader));
}
static void dev_exit(struct fp_img_dev *dev)
{
do_exit(dev);
libusb_release_interface(dev->udev, 0);
}
static const struct aes_regwrite finger_det_reqs[] = {
{ 0x80, 0x01 },
{ 0x80, 0x12 },
{ 0x85, 0x00 },
{ 0x8A, 0x00 },
{ 0x8B, 0x0E },
{ 0x8C, 0x90 },
{ 0x8D, 0x83 },
{ 0x8E, 0x07 },
{ 0x8F, 0x07 },
{ 0x96, 0x00 },
{ 0x97, 0x48 },
{ 0xA1, 0x00 },
{ 0xA2, 0x50 },
{ 0xA6, 0xE4 },
{ 0xAD, 0x08 },
{ 0xAE, 0x5B },
{ 0xAF, 0x54 },
{ 0xB1, 0x28 },
{ 0xB5, 0xAB },
{ 0xB6, 0x0E },
{ 0x1B, 0x2D },
{ 0x81, 0x04 }
};
static const struct aes_regwrite finger_det_none[] = {
{ 0x80, 0x01 },
{ 0x82, 0x00 },
{ 0x86, 0x00 },
{ 0xB1, 0x28 },
{ 0x1D, 0x00 }
};
static int detect_finger(struct fp_img_dev *dev)
{
unsigned char buffer[19];
int r;
int i;
int sum = 0;
r = aes_write_regv(dev, finger_det_reqs, G_N_ELEMENTS(finger_det_reqs));
if (r < 0)
return r;
r = read_data(dev, buffer, 19);
if (r < 0)
return r;
for (i = 3; i < 17; i++)
sum += (buffer[i] & 0xf) + (buffer[i] >> 4);
/* We need to answer something if no finger has been detected */
if (sum <= 20) {
r = aes_write_regv(dev, finger_det_none, G_N_ELEMENTS(finger_det_none));
if (r < 0)
return r;
}
return sum > 20;
}
static int await_finger_on(struct fp_img_dev *dev)
{
int r;
do {
r = detect_finger(dev);
} while (r == 0);
return (r < 0) ? r : 0;
}
/* find overlapping parts of frames */
static unsigned int find_overlap(unsigned char *first_frame,
unsigned char *second_frame, unsigned int *min_error)
{
unsigned int dy;
unsigned int not_overlapped_height = 0;
*min_error = 255 * FRAME_SIZE;
for (dy = 0; dy < FRAME_HEIGHT; dy++) {
/* Calculating difference (error) between parts of frames */
unsigned int i;
unsigned int error = 0;
for (i = 0; i < FRAME_WIDTH * (FRAME_HEIGHT - dy); i++) {
/* Using ? operator to avoid abs function */
error += first_frame[i] > second_frame[i] ?
(first_frame[i] - second_frame[i]) :
(second_frame[i] - first_frame[i]);
}
/* Normalize error */
error *= 15;
error /= i;
if (error < *min_error) {
*min_error = error;
not_overlapped_height = dy;
}
first_frame += FRAME_WIDTH;
}
return not_overlapped_height;
}
/* assemble a series of frames into a single image */
static unsigned int assemble(unsigned char *input, unsigned char *output,
int num_strips, gboolean reverse, unsigned int *errors_sum)
{
uint8_t *assembled = output;
int frame;
uint32_t image_height = FRAME_HEIGHT;
unsigned int min_error;
*errors_sum = 0;
if (num_strips < 1)
return 0;
/* Rotating given data by 90 degrees
* Taken from document describing aes1610 image format
* TODO: move reversing detection here */
if (reverse)
output += (num_strips - 1) * FRAME_SIZE;
for (frame = 0; frame < num_strips; frame++) {
aes_assemble_image(input, FRAME_WIDTH, FRAME_HEIGHT, output);
input += FRAME_WIDTH * (FRAME_HEIGHT / 2);
if (reverse)
output -= FRAME_SIZE;
else
output += FRAME_SIZE;
}
/* Detecting where frames overlaped */
output = assembled;
for (frame = 1; frame < num_strips; frame++) {
int not_overlapped;
output += FRAME_SIZE;
not_overlapped = find_overlap(assembled, output, &min_error);
*errors_sum += min_error;
image_height += not_overlapped;
assembled += FRAME_WIDTH * not_overlapped;
memcpy(assembled, output, FRAME_SIZE);
}
return image_height;
}
static const struct aes_regwrite capture_reqs[] = {
{ 0x80, 0x01 },
{ 0x80, 0x12 },
{ 0x84, 0x01 },
{ 0x85, 0x00 },
{ 0x89, 0x64 },
{ 0x8A, 0x00 },
{ 0x8B, 0x0E },
{ 0x8C, 0x90 },
{ 0xBE, 0x23 },
{ 0x29, 0x06 },
{ 0x2A, 0x35 },
{ 0x96, 0x00 },
{ 0x98, 0x03 },
{ 0x99, 0x00 },
{ 0x9C, 0xA5 },
{ 0x9D, 0x40 },
{ 0x9E, 0xC6 },
{ 0x9F, 0x8E },
{ 0xA2, 0x50 },
{ 0xA3, 0xF0 },
{ 0xAD, 0x08 },
{ 0xBD, 0x4F },
{ 0xAF, 0x54 },
{ 0xB1, 0x08 },
{ 0xB5, 0xAB },
{ 0x1B, 0x2D },
{ 0xB6, 0x4E },
{ 0xB8, 0x70 },
{ 0x2B, 0xB3 },
{ 0x2C, 0x5D },
{ 0x2D, 0x98 },
{ 0x2E, 0xB0 },
{ 0x2F, 0x20 },
{ 0xA2, 0xD0 },
{ 0x1D, 0x21 },
{ 0x1E, 0xBE },
{ 0x1C, 0x00 },
{ 0x1D, 0x30 },
{ 0x1E, 0x29 },
{ 0x1C, 0x01 },
{ 0x1D, 0x00 },
{ 0x1E, 0x9E },
{ 0x1C, 0x02 },
{ 0x1D, 0x30 },
{ 0x1E, 0xBB },
{ 0x1C, 0x03 },
{ 0x1D, 0x00 },
{ 0x1E, 0x9D },
{ 0x1C, 0x04 },
{ 0x1D, 0x22 },
{ 0x1E, 0xFF },
{ 0x1C, 0x05 },
{ 0x1D, 0x1B },
{ 0x1E, 0x4E },
{ 0x1C, 0x06 },
{ 0x1D, 0x16 },
{ 0x1E, 0x28 },
{ 0x1C, 0x07 },
{ 0x1D, 0x22 },
{ 0x1E, 0xFF },
{ 0x1C, 0x08 },
{ 0x1D, 0x15 },
{ 0x1E, 0xF1 },
{ 0x1C, 0x09 },
{ 0x1D, 0x30 },
{ 0x1E, 0xD5 },
{ 0x1C, 0x0A },
{ 0x1D, 0x00 },
{ 0x1E, 0x9E },
{ 0x1C, 0x0B },
{ 0x1D, 0x17 },
{ 0x1E, 0x9D },
{ 0x1C, 0x0C },
{ 0x1D, 0x28 },
{ 0x1E, 0xD7 },
{ 0x1C, 0x0D },
{ 0x1D, 0x17 },
{ 0x1E, 0xD7 },
{ 0x1C, 0x0E },
{ 0x1D, 0x0A },
{ 0x1E, 0xCB },
{ 0x1C, 0x0F },
{ 0x1D, 0x24 },
{ 0x1E, 0x14 },
{ 0x1C, 0x10 },
{ 0x1D, 0x17 },
{ 0x1E, 0x85 },
{ 0x1C, 0x11 },
{ 0x1D, 0x15 },
{ 0x1E, 0x71 },
{ 0x1C, 0x12 },
{ 0x1D, 0x2B },
{ 0x1E, 0x36 },
{ 0x1C, 0x13 },
{ 0x1D, 0x12 },
{ 0x1E, 0x06 },
{ 0x1C, 0x14 },
{ 0x1D, 0x30 },
{ 0x1E, 0x97 },
{ 0x1C, 0x15 },
{ 0x1D, 0x21 },
{ 0x1E, 0x32 },
{ 0x1C, 0x16 },
{ 0x1D, 0x06 },
{ 0x1E, 0xE6 },
{ 0x1C, 0x17 },
{ 0x1D, 0x16 },
{ 0x1E, 0x06 },
{ 0x1C, 0x18 },
{ 0x1D, 0x30 },
{ 0x1E, 0x01 },
{ 0x1C, 0x19 },
{ 0x1D, 0x21 },
{ 0x1E, 0x37 },
{ 0x1C, 0x1A },
{ 0x1D, 0x00 },
{ 0x1E, 0x08 },
{ 0x1C, 0x1B },
{ 0x1D, 0x80 },
{ 0x1E, 0xD5 },
{ 0xA2, 0x50 },
{ 0xA2, 0x50 },
{ 0x81, 0x01 }
};
static const struct aes_regwrite strip_scan_reqs[] = {
{ 0xBE, 0x23 },
{ 0x29, 0x06 },
{ 0x2A, 0x35 },
{ 0xBD, 0x4F },
{ 0xFF, 0x00 }
};
static const struct aes_regwrite capture_stop[] = {
{ 0x81,0x00 }
};
static int capture(struct fp_img_dev *dev, gboolean unconditional,
struct fp_img **ret)
{
int r;
struct fp_img *img;
unsigned int nstrips;
unsigned int errors_sum, r_errors_sum;
unsigned char *cooked;
unsigned char *imgptr;
unsigned char buf[665];
int final_size;
int sum;
unsigned int count_blank = 0;
int i;
/* FIXME can do better here in terms of buffer management? */
fp_dbg("");
r = aes_write_regv(dev, capture_reqs, G_N_ELEMENTS(capture_reqs));
if (r < 0)
return r;
/* FIXME: use histogram data above for gain calibration (0x8e xx) */
img = fpi_img_new((3 * MAX_FRAMES * FRAME_SIZE) / 2);
imgptr = img->data;
cooked = imgptr + (MAX_FRAMES * FRAME_SIZE) / 2;
r = read_data(dev, buf, 665);
if (r < 0)
goto err;
memcpy(imgptr, buf + 1, 128*4);
imgptr += 128*4;
r = read_data(dev, buf, 665);
if (r < 0)
goto err;
memcpy(imgptr, buf + 1, 128*4);
imgptr += 128*4;
/* we start at 2 because we captured 2 frames above. the above captures
* should possibly be moved into the loop below, or discarded altogether */
for (nstrips = 2; nstrips < MAX_FRAMES - 2; nstrips++) {
r = aes_write_regv(dev, strip_scan_reqs, G_N_ELEMENTS(strip_scan_reqs));
if (r < 0)
goto err;
r = read_data(dev, buf, 665);
if (r < 0)
goto err;
memcpy(imgptr, buf + 1, 128*4);
imgptr += 128*4;
r = read_data(dev, buf, 665);
if (r < 0)
goto err;
memcpy(imgptr, buf + 1, 128*4);
imgptr += 128*4;
sum = 0;
for (i = 515; i != 530; i++)
{
/* histogram[i] = number of pixels of value i
Only the pixel values from 10 to 15 are used to detect finger. */
sum += buf[i];
}
if (sum < 0) {
r = sum;
goto err;
}
fp_dbg("sum=%d", sum);
if (sum == 0)
count_blank++;
else
count_blank = 0;
/* if we got 50 blank frames, assume scan has ended. */
if (count_blank >= 50)
break;
}
r = aes_write_regv(dev, capture_stop, G_N_ELEMENTS(capture_stop));
if (r < 0)
goto err;
r = read_data(dev, buf, 665);
if (r < 0)
goto err;
memcpy(imgptr, buf + 1, 128*4);
imgptr += 128*4;
nstrips++;
r = read_data(dev, buf, 665);
if (r < 0)
goto err;
memcpy(imgptr, buf + 1, 128*4);
imgptr += 128*4;
nstrips++;
if (nstrips == MAX_FRAMES)
fp_warn("swiping finger too slow?");
img->flags = FP_IMG_COLORS_INVERTED;
img->height = assemble(img->data, cooked, nstrips, FALSE, &errors_sum);
img->height = assemble(img->data, cooked, nstrips, TRUE, &r_errors_sum);
if (r_errors_sum > errors_sum) {
img->height = assemble(img->data, cooked, nstrips, FALSE, &errors_sum);
img->flags |= FP_IMG_V_FLIPPED | FP_IMG_H_FLIPPED;
fp_dbg("normal scan direction");
} else {
fp_dbg("reversed scan direction");
}
final_size = img->height * FRAME_WIDTH;
memcpy(img->data, cooked, final_size);
img = fpi_img_resize(img, final_size);
*ret = img;
return 0;
err:
fp_img_free(img);
return r;
}
static const struct usb_id id_table[] = {
{ .vendor = 0x08ff, .product = 0x1600 },
{ 0, 0, 0, },
};
struct fp_img_driver aes1610_driver = {
.driver = {
.id = 6,
.name = FP_COMPONENT,
.full_name = "AuthenTec AES1610",
.id_table = id_table,
.scan_type = FP_SCAN_TYPE_SWIPE,
},
.flags = 0,
.img_height = -1,
.img_width = 128,
/* temporarily lowered until we sort out image processing code
* binarized scan quality is good, minutiae detection is accurate,
* it's just that we get fewer minutiae than other scanners (less scanning
* area) */
.bz3_threshold = 10,
.init = dev_init,
.exit = dev_exit,
.await_finger_on = await_finger_on,
.capture = capture,
};

1254
libfprint-aes1610-driver.patch
View File

File diff suppressed because it is too large Load Diff

23
libfprint.spec
View File

@ -1,20 +1,13 @@
Name: libfprint
Version: 0.1.0
Release: 16.pre3%{?dist}
Version: 0.2.0
Release: 1%{?dist}
Summary: Tool kit for fingerprint scanner
Group: System Environment/Libraries
License: LGPLv2+
URL: http://www.reactivated.net/fprint/wiki/Main_Page
Source0: http://downloads.sourceforge.net/fprint/%{name}-0.1.0-pre2.tar.bz2
Source0: http://freedesktop.org/~hadess/%{name}-%{version}.tar.bz2
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
# http://thread.gmane.org/gmane.linux.fprint/1321
Patch1: 0001-Add-udev-rules-to-set-devices-to-autosuspend.patch
# https://bugzilla.redhat.com/show_bug.cgi?id=472103
Patch2: 0001-Add-gdk-pixbuf-support.patch
# https://bugzilla.redhat.com/show_bug.cgi?id=499732
Source1: aes1610.c
Patch3: libfprint-aes1610-driver.patch
ExcludeArch: s390 s390x
BuildRequires: libusb1-devel glib2-devel gtk2-devel openssl-devel
@ -38,14 +31,9 @@ developing applications that use %{name}.
%prep
%setup -q -n %{name}-0.1.0-pre2
%patch1 -p1
%patch2 -p1
cp -a %{SOURCE1} libfprint/drivers
%patch3 -p1 -b .aes1610
%setup -q
%build
autoreconf -f -i
%configure --disable-static
make %{?_smp_mflags}
pushd doc
@ -82,6 +70,9 @@ rm -rf $RPM_BUILD_ROOT
%{_libdir}/pkgconfig/%{name}.pc
%changelog
* Thu Aug 19 2010 Bastien Nocera <bnocera@redhat.com> 0.2.0-1
- Update to 0.2.0
* Wed Jun 30 2010 Matthew Garrett <mjg@redhat.com> 0.1.0-16.pre3
- Fix #505438 to avoid message on boot on some systems

2
sources
View File

@ -1 +1 @@
f0e7fb9438fe17fba642fe59778d668e libfprint-0.1.0-pre2.tar.bz2
f4cd1daf59b79f4f02ee77f0603189e9 libfprint-0.2.0.tar.bz2