Attachment #408804 for bug #531698

Lines 23-29 AC_SUBST(lt_major) Link Here

(-)a/configure.ac (-1 / +12 lines)
23	AC_SUBST(lt_revision)	23	AC_SUBST(lt_revision)
24	AC_SUBST(lt_age)	24	AC_SUBST(lt_age)
25		25
26	all_drivers="upekts upektc upeksonly vcom5s uru4000 fdu2000 aes1610 aes1660 aes2501 aes2550 aes2660 aes3500 aes4000 vfs101 vfs301 vfs5011 upektc_img etes603"	26	all_drivers="upekts upektc upeksonly vcom5s uru4000 fdu2000 aes1610 aes1660 aes2501 aes2550 aes2660 aes3500 aes4000 vfs101 vfs301 vfs5011 upektc_img etes603 vfs0050"
27		27
28	require_imaging='no'	28	require_imaging='no'
29	require_aeslib='no'	29	require_aeslib='no'
Lines 48-53 enable_vfs301='no' Link Here
48	enable_vfs5011='no'	48	enable_vfs5011='no'
49	enable_upektc_img='no'	49	enable_upektc_img='no'
50	enable_etes603='no'	50	enable_etes603='no'
		51	enable_vfs0050='no'
51		52
52	AC_ARG_WITH([drivers],[AS_HELP_STRING([--with-drivers],	53	AC_ARG_WITH([drivers],[AS_HELP_STRING([--with-drivers],
53	[List of drivers to enable])],	54	[List of drivers to enable])],
Lines 150-155 for driver in `echo ${drivers} \| sed -e 's/,/ /g' -e 's/,$//g'`; do Link Here
150	AC_DEFINE([ENABLE_ETES603], [], [Build EgisTec ES603 driver])	151	AC_DEFINE([ENABLE_ETES603], [], [Build EgisTec ES603 driver])
151	enable_etes603="yes"	152	enable_etes603="yes"
152	;;	153	;;
		154	vfs0050)
		155	AC_DEFINE([ENABLE_VFS0050], [], [Build Validity VFS0050 driver])
		156	enable_vfs0050="yes"
		157	;;
153	esac	158	esac
154	done	159	done
155		160
Lines 175-180 AM_CONDITIONAL([ENABLE_VFS301], [test "$enable_vfs301" = "yes"]) Link Here
175	AM_CONDITIONAL([ENABLE_VFS5011], [test "$enable_vfs5011" = "yes"])	180	AM_CONDITIONAL([ENABLE_VFS5011], [test "$enable_vfs5011" = "yes"])
176	AM_CONDITIONAL([ENABLE_UPEKTC_IMG], [test "$enable_upektc_img" = "yes"])	181	AM_CONDITIONAL([ENABLE_UPEKTC_IMG], [test "$enable_upektc_img" = "yes"])
177	AM_CONDITIONAL([ENABLE_ETES603], [test "$enable_etes603" = "yes"])	182	AM_CONDITIONAL([ENABLE_ETES603], [test "$enable_etes603" = "yes"])
		183	AM_CONDITIONAL([ENABLE_VFS0050], [test "$enable_vfs0050" = "yes"])
178		184
179		185
180	PKG_CHECK_MODULES(LIBUSB, [libusb-1.0 >= 0.9.1])	186	PKG_CHECK_MODULES(LIBUSB, [libusb-1.0 >= 0.9.1])
Lines 396-401 if test x$enable_etes603 != xno ; then Link Here
396	else	402	else
397	AC_MSG_NOTICE([ etes603 driver disabled])	403	AC_MSG_NOTICE([ etes603 driver disabled])
398	fi	404	fi
		405	if test x$enable_vfs0050 != xno ; then
		406	AC_MSG_NOTICE([** vfs0050 driver enabled])
		407	else
		408	AC_MSG_NOTICE([ vfs0050 driver disabled])
		409	fi
399	if test x$require_aeslib != xno ; then	410	if test x$require_aeslib != xno ; then
400	AC_MSG_NOTICE([** aeslib helper functions enabled])	411	AC_MSG_NOTICE([** aeslib helper functions enabled])
401	else	412	else

Lines 21-26 VFS301_SRC = drivers/vfs301.c drivers/vfs301_proto.c drivers/vfs301_proto.h dri Link Here

(-)a/libfprint/Makefile.am (+6 lines)
21	VFS5011_SRC = drivers/vfs5011.c drivers/vfs5011_proto.h	21	VFS5011_SRC = drivers/vfs5011.c drivers/vfs5011_proto.h
22	UPEKTC_IMG_SRC = drivers/upektc_img.c drivers/upektc_img.h	22	UPEKTC_IMG_SRC = drivers/upektc_img.c drivers/upektc_img.h
23	ETES603_SRC = drivers/etes603.c	23	ETES603_SRC = drivers/etes603.c
		24	VFS0050_SRC = drivers/vfs0050.c drivers/vfs0050.h
24		25
25	EXTRA_DIST = \	26	EXTRA_DIST = \
26	$(UPEKE2_SRC) \	27	$(UPEKE2_SRC) \
Lines 42-47 EXTRA_DIST = \ Link Here
42	$(VFS5011_SRC) \	43	$(VFS5011_SRC) \
43	$(UPEKTC_IMG_SRC) \	44	$(UPEKTC_IMG_SRC) \
44	$(ETES603_SRC) \	45	$(ETES603_SRC) \
		46	$(VFS0050_SRC) \
45	drivers/aesx660.c \	47	drivers/aesx660.c \
46	drivers/aesx660.h \	48	drivers/aesx660.h \
47	drivers/aes3k.c \	49	drivers/aes3k.c \
Lines 182-187 if ENABLE_ETES603 Link Here
182	DRIVER_SRC += $(ETES603_SRC)	184	DRIVER_SRC += $(ETES603_SRC)
183	endif	185	endif
184		186
		187	if ENABLE_VFS0050
		188	DRIVER_SRC += $(VFS0050_SRC)
		189	endif
		190
185	if REQUIRE_PIXMAN	191	if REQUIRE_PIXMAN
186	OTHER_SRC += pixman.c	192	OTHER_SRC += pixman.c
187	libfprint_la_CFLAGS += $(IMAGING_CFLAGS)	193	libfprint_la_CFLAGS += $(IMAGING_CFLAGS)

Lines 398-403 static struct fp_img_driver * const img_drivers[] = { Link Here

(-)a/libfprint/core.c (+3 lines)
398	#ifdef ENABLE_ETES603	398	#ifdef ENABLE_ETES603
399	&etes603_driver,	399	&etes603_driver,
400	#endif	400	#endif
		401	#ifdef ENABLE_VFS0050
		402	&vfs0050_driver,
		403	#endif
401	/*#ifdef ENABLE_FDU2000	404	/*#ifdef ENABLE_FDU2000
402	&fdu2000_driver,	405	&fdu2000_driver,
403	#endif	406	#endif

Lines 40-45 enum { Link Here

(-)a/libfprint/drivers/driver_ids.h (+1 lines)
40	UPEKTC_IMG_ID = 17,	40	UPEKTC_IMG_ID = 17,
41	ETES603_ID = 18,	41	ETES603_ID = 18,
42	VFS5011_ID = 19,	42	VFS5011_ID = 19,
		43	VFS0050_ID = 20,
43	};	44	};
44		45
45	#endif	46	#endif




/*
 * Validity VFS0050 driver for libfprint
 * Copyright (C) 2015 Konstantin Semenov <zemen17@gmail.com>
 *
 * 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 "vfs0050"

#include <errno.h>
#include <fp_internal.h>
#include "driver_ids.h"

#include <memory.h>

#include "vfs0050.h"

/* USB functions */

/* Callback for async_write */
static void async_write_callback(struct libusb_transfer *transfer)
{
	struct fpi_ssm *ssm = transfer->user_data;
	struct fp_img_dev *idev = ssm->priv;

	int transferred = transfer->actual_length, error =
	    transfer->status, len = transfer->length;

	libusb_free_transfer(transfer);

	if (error != 0) {
		fp_err("USB write transfer: %s", libusb_error_name(error));
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	if (transferred != len) {
		fp_err("Written only %d of %d bytes", transferred, len);
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	fpi_ssm_next_state(ssm);
}

/* Send data to EP1, the only out endpoint */
static void async_write(struct fpi_ssm *ssm, void *data, int len)
{
	struct fp_img_dev *idev = ssm->priv;
	struct libusb_device_handle *udev = idev->udev;
	struct vfs_dev_t *vdev = idev->priv;

	vdev->transfer = libusb_alloc_transfer(0);
	libusb_fill_bulk_transfer(vdev->transfer, udev, 0x01, data, len,
				  async_write_callback, ssm, VFS_USB_TIMEOUT);
	libusb_submit_transfer(vdev->transfer);
}

/* Callback for async_read */
static void async_read_callback(struct libusb_transfer *transfer)
{
	struct fpi_ssm *ssm = transfer->user_data;
	struct fp_img_dev *idev = ssm->priv;

	int transferred = transfer->actual_length, error =
	    transfer->status, len = transfer->length;
	int ep = transfer->endpoint;

	libusb_free_transfer(transfer);

	if (error != 0) {
		fp_err("USB read transfer on endpoint %d: %s", ep - 0x80,
		       libusb_error_name(error));
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	if (transferred != len) {
		fp_err("Received %d instead of %d bytes", transferred, len);
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	fpi_ssm_next_state(ssm);
}

/* Receive data from the given ep and compare with expected */
static void async_read(struct fpi_ssm *ssm, int ep, void *data, int len)
{
	struct fp_img_dev *idev = ssm->priv;
	struct libusb_device_handle *udev = idev->udev;
	struct vfs_dev_t *vdev = idev->priv;

	ep += 0x80;

	vdev->transfer = libusb_alloc_transfer(0);

	/* 0x83 is the only interrupt endpoint */
	if (ep == 0x83)
		libusb_fill_interrupt_transfer(vdev->transfer, udev, ep, data,
					       len, async_read_callback, ssm,
					       VFS_USB_TIMEOUT);
	else
		libusb_fill_bulk_transfer(vdev->transfer, udev, ep, data, len,
					  async_read_callback, ssm,
					  VFS_USB_TIMEOUT);
	libusb_submit_transfer(vdev->transfer);
}

/* Callback for async_read */
static void async_abort_callback(struct libusb_transfer *transfer)
{
	struct fpi_ssm *ssm = transfer->user_data;
	struct fp_img_dev *idev = ssm->priv;

	int transferred = transfer->actual_length, error = transfer->status;
	int ep = transfer->endpoint;

	/* Free trash buffer, we don't need it */
	g_free(transfer->buffer);
	libusb_free_transfer(transfer);

	/* In normal case endpoint is empty */
	if (error == LIBUSB_TRANSFER_TIMED_OUT) {
		fpi_ssm_next_state(ssm);
		return;
	}

	if (error != 0) {
		fp_err("USB write transfer: %s", libusb_error_name(error));
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	/* Don't stop process, only print warning */
	if (transferred > 0)
		fp_warn("Endpoint %d had extra %d bytes", ep - 0x80,
			transferred);

	fpi_ssm_jump_to_state(ssm, ssm->cur_state);
}

/* Receive data from the given ep and compare with expected */
static void async_abort(struct fpi_ssm *ssm, int ep)
{
	struct fp_img_dev *idev = ssm->priv;
	struct libusb_device_handle *udev = idev->udev;
	struct vfs_dev_t *vdev = idev->priv;

	int len = VFS_USB_BUFFER_SIZE;
	unsigned char *data = g_malloc(VFS_USB_BUFFER_SIZE);

	ep += 0x80;

	vdev->transfer = libusb_alloc_transfer(0);

	/* 0x83 is the only interrupt endpoint */
	if (ep == 0x83)
		libusb_fill_interrupt_transfer(vdev->transfer, udev, ep, data,
					       len, async_abort_callback, ssm,
					       VFS_USB_ABORT_TIMEOUT);
	else
		libusb_fill_bulk_transfer(vdev->transfer, udev, ep, data, len,
					  async_abort_callback, ssm,
					  VFS_USB_ABORT_TIMEOUT);
	libusb_submit_transfer(vdev->transfer);
}

/* Proto functions */

/* SSM loop for clear_ep2 */
static void clear_ep2_ssm(struct fpi_ssm *ssm)
{
	struct fp_img_dev *idev = ssm->priv;

	short result;
	char command04 = 0x04;

	switch (ssm->cur_state) {
	case SUBSM1_COMMAND_04:
		async_write(ssm, &command04, sizeof(command04));
		break;

	case SUBSM1_RETURN_CODE:
		async_read(ssm, 1, &result, sizeof(result));
		break;

	case SUBSM1_ABORT_2:
		async_abort(ssm, 2);
		break;

	default:
		fp_err("Unknown SUBSM1 state");
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
	}
}

/* Send command to clear EP2 */
static void clear_ep2(struct fpi_ssm *ssm)
{
	struct fp_img_dev *idev = ssm->priv;

	struct fpi_ssm *subsm =
	    fpi_ssm_new(idev->dev, clear_ep2_ssm, SUBSM1_STATES);
	subsm->priv = idev;
	fpi_ssm_start_subsm(ssm, subsm);
}

static void send_control_packet_ssm(struct fpi_ssm *ssm)
{
	struct fp_img_dev *idev = ssm->priv;
	struct vfs_dev_t *vdev = idev->priv;

	short result;
	unsigned char *commit_result = NULL;

	switch (ssm->cur_state) {
	case SUBSM2_SEND_CONTROL:
		async_write(ssm, vdev->control_packet, VFS_CONTROL_PACKET_SIZE);
		break;

	case SUBSM2_RETURN_CODE:
		async_read(ssm, 1, &result, sizeof(result));
		break;

	case SUBSM2_SEND_COMMIT:
		/* next_receive_* packets could be sent only in pair */
		if (vdev->control_packet == next_receive_1) {
			vdev->control_packet = next_receive_2;
			fpi_ssm_jump_to_state(ssm, SUBSM2_SEND_CONTROL);
			break;
		}
		/* commit_out in Windows differs in each commit, but I send the same each time */
		async_write(ssm, commit_out, sizeof(commit_out));
		break;

	case SUBSM2_COMMIT_RESPONSE:
		commit_result = g_malloc(VFS_COMMIT_RESPONSE_SIZE);
		async_read(ssm, 1, commit_result, VFS_COMMIT_RESPONSE_SIZE);
		break;

	case SUBSM2_READ_EMPTY_INTERRUPT:
		/* I don't know how to check result, it could be different */
		g_free(commit_result);

		async_read(ssm, 3, vdev->interrupt, VFS_INTERRUPT_SIZE);
		break;

	case SUBSM2_ABORT_3:
		/* Check that interrupt is empty */
		if (memcmp
		    (vdev->interrupt, empty_interrupt, VFS_INTERRUPT_SIZE)) {
			fp_err("Unknown SUBSM2 state");
			fpi_imgdev_session_error(idev, -EIO);
			fpi_ssm_mark_aborted(ssm, -EIO);
			break;
		}
		async_abort(ssm, 3);
		break;

	case SUBSM2_CLEAR_EP2:
		/* After turn_on Windows doesn't clear EP2 */
		if (vdev->control_packet != turn_on)
			clear_ep2(ssm);
		else
			fpi_ssm_next_state(ssm);
		break;

	default:
		fp_err("Unknown SUBSM2 state");
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
	}
}

/* Send device state control packet */
static void send_control_packet(struct fpi_ssm *ssm)
{
	struct fp_img_dev *idev = ssm->priv;

	struct fpi_ssm *subsm =
	    fpi_ssm_new(idev->dev, send_control_packet_ssm, SUBSM2_STATES);
	subsm->priv = idev;
	fpi_ssm_start_subsm(ssm, subsm);
}

/* Clears all fprint data */
static void clear_data(struct vfs_dev_t *vdev)
{
	if (vdev->data != NULL)
		g_free(vdev->data);
	vdev->data = NULL;
	vdev->memory = vdev->bytes = 0;
}

#define VFS_NOISE_THRESHOLD 50

/* Processes image before submitting. This function needs to be improved */
static void prepare_image(struct fp_img *img, struct vfs_line *data)
{
	/* TODO: clean other falanges from print */

	/* Noise cleaning. IMHO, it works pretty well
	   I've not detected cases when it doesn't work or cuts a part of the finger
	   Noise arises at the end of scan when some water remains on the scanner */
	while (img->height > 0) {
		int val1 = data[img->height - 1].noise_hash_1;
		int val2 = data[img->height - 1].noise_hash_2;
		if (val1 > VFS_NOISE_THRESHOLD
		    && val1 < 256 - VFS_NOISE_THRESHOLD
		    && val2 > VFS_NOISE_THRESHOLD
		    && val2 < 256 - VFS_NOISE_THRESHOLD)
			break;
		--img->height;
	}
	fpi_img_resize(img, img->width * img->height);

	/* If image is not good enough */
	if (img->height < img->width) {
		img->height = img->width;
		fpi_img_resize(img, img->width * img->height);
		memset(img->data, 0, img->width * img->height);
		return;
	}

	/* Pixman downscaling(too big images are processed slow or cause segfault during minutae detection)
	   TODO: make scaling uniform using timeline data from last eight bytes */

	if (img->height > VFS_MAX_HEIGHT)
		fpi_im_downscale(img, 1.0,
				 (double)VFS_MAX_HEIGHT / img->height);
}

/* Creates image from raw scanner data */
static struct fp_img *get_raw_image(struct vfs_dev_t *vdev)
{
	struct vfs_line *data = (struct vfs_line *)vdev->data;
	int height = vdev->bytes / VFS_IMAGE_WIDTH;
	int width = VFS_RESULT_IMAGE_WIDTH;

	struct fp_img *img = fpi_img_new(width * height);
	img->width = width, img->height = height;
	img->flags = FP_IMG_V_FLIPPED;
	for (int x = 0; x < height; ++x)
		memcpy(img->data + x * width, data[x].data, width);

	return img;
}

/* Processes and submits image after fingerprint received */
static void submit_image(struct fp_img_dev *idev)
{
	struct vfs_dev_t *vdev = idev->priv;

	/* We were not asked to submit image actually */
	if (!vdev->active)
		return;

	struct fp_img *img = get_raw_image(vdev);
	prepare_image(img, (struct vfs_line *)vdev->data);

	fpi_imgdev_image_captured(idev, img);

	/* Finger not on the scanner */
	fpi_imgdev_report_finger_status(idev, 0);
}

/* After receiving interrupt from EP3 */
static void interrupt_callback(struct libusb_transfer *transfer)
{
	struct fpi_ssm *ssm = transfer->user_data;
	struct fp_img_dev *idev = ssm->priv;
	struct vfs_dev_t *vdev = idev->priv;

	char *interrupt = vdev->interrupt;
	int error = transfer->status, transferred = transfer->actual_length;

	libusb_free_transfer(transfer);

	vdev->wait_interrupt = 0;

	/* When we have cancelled transfer, error is ok actually */
	if (!vdev->active && error == LIBUSB_TRANSFER_CANCELLED)
		return;

	if (error != 0) {
		fp_err("USB read interrupt transfer: %s",
		       libusb_error_name(error));
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	/* Interrupt size is VFS_INTERRUPT_SIZE bytes in all known cases */
	if (transferred != VFS_INTERRUPT_SIZE) {
		fp_err("Unknown interrupt size %d", transferred);
		libusb_free_transfer(transfer);
		/* Abort ssm */
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	if (memcmp(interrupt, interrupt2, VFS_INTERRUPT_SIZE) == 0) {
		/* Go to the next ssm stage */
		fpi_ssm_next_state(ssm);
		return;
	}

	if (memcmp(interrupt, interrupt3, VFS_INTERRUPT_SIZE) == 0) {
		/* Go to the next ssm stage */
		fpi_ssm_next_state(ssm);
		return;
	}

	/* Standard interrupt */
	if (memcmp(interrupt, interrupt1, VFS_INTERRUPT_SIZE) == 0) {
		/* Go to the next ssm stage */
		fpi_ssm_next_state(ssm);
		return;
	}

	/* When finger is on the scanner before turn_on */
	if (interrupt[0] == 0x01) {
		fp_warn("Finger is already on the scanner");

		/* Go to the next ssm stage */
		fpi_ssm_next_state(ssm);
		return;
	}

	/* TODO: handle all interrupts */
	fp_err("Unknown interrupt '%02x:%02x:%02x:%02x:%02x'!",
	       interrupt[0] & 0xff, interrupt[1] & 0xff, interrupt[2] & 0xff,
	       interrupt[3] & 0xff, interrupt[4] & 0xff);

	/* Abort ssm */
	fpi_imgdev_session_error(idev, -EIO);
	fpi_ssm_mark_aborted(ssm, -EIO);
}

static void receive_callback(struct libusb_transfer *transfer)
{
	struct fpi_ssm *ssm = transfer->user_data;
	struct fp_img_dev *idev = ssm->priv;
	struct vfs_dev_t *vdev = idev->priv;

	int transferred = transfer->actual_length, error = transfer->status;

	libusb_free_transfer(transfer);

	if (error != 0 && error != LIBUSB_TRANSFER_TIMED_OUT) {
		fp_err("USB read transfer: %s", libusb_error_name(error));

		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
		return;
	}

	/* Check if fingerprint data is over */
	if (transferred == 0)
		fpi_ssm_next_state(ssm);
	else {
		/* We need more data */
		vdev->bytes += transferred;
		fpi_ssm_jump_to_state(ssm, ssm->cur_state);
	}
}

/* Stub to keep SSM alive when waiting an interrupt */
static void wait_interrupt(void *data)
{
	struct fpi_ssm *ssm = data;
	struct fp_img_dev *idev = ssm->priv;
	struct vfs_dev_t *vdev = idev->priv;

	/* Keep sleeping while this flag is on */
	if (vdev->wait_interrupt)
		fpi_ssm_jump_to_state(ssm, ssm->cur_state);
}

/* SSM stub to prepare device to another scan after orange light was on */
static void another_scan(void *data)
{
	struct fpi_ssm *ssm = data;
	fpi_ssm_jump_to_state(ssm, SSM_TURN_ON);
}

/* Another SSM stub to continue after waiting for probable vdev->active changes */
static void scan_completed(void *data)
{
	struct fpi_ssm *ssm = data;
	fpi_ssm_next_state(ssm);
}

/* Main SSM loop */
static void activate_ssm(struct fpi_ssm *ssm)
{
	struct fp_img_dev *idev = ssm->priv;
	struct libusb_device_handle *udev = idev->udev;
	struct vfs_dev_t *vdev = idev->priv;

	switch (ssm->cur_state) {
	case SSM_INITIAL_ABORT_1:
		async_abort(ssm, 1);
		break;

	case SSM_INITIAL_ABORT_2:
		async_abort(ssm, 2);
		break;

	case SSM_INITIAL_ABORT_3:
		async_abort(ssm, 3);
		break;

	case SSM_CLEAR_EP2:
		clear_ep2(ssm);
		break;

	case SSM_TURN_OFF:
		/* Set control_packet argument */
		vdev->control_packet = turn_off;

		send_control_packet(ssm);
		break;

	case SSM_TURN_ON:
		if (!vdev->active) {
			/* The only correct exit */
			fpi_ssm_mark_completed(ssm);

			if (vdev->need_report) {
				fpi_imgdev_deactivate_complete(idev);
				vdev->need_report = 0;
			}
			break;
		}
		/* Set control_packet argument */
		vdev->control_packet = turn_on;

		send_control_packet(ssm);
		break;

	case SSM_ASK_INTERRUPT:
		/* Activated, light must be blinking now */

		/* If we first time here, report that activate completed */
		if (vdev->need_report) {
			fpi_imgdev_activate_complete(idev, 0);
			vdev->need_report = 0;
		}

		/* Asyncronously enquire an interrupt */
		vdev->transfer = libusb_alloc_transfer(0);
		libusb_fill_interrupt_transfer(vdev->transfer, udev, 0x83,
					       vdev->interrupt,
					       VFS_INTERRUPT_SIZE,
					       interrupt_callback, ssm, 0);
		libusb_submit_transfer(vdev->transfer);

		/* This flag could be turned off only in callback function */
		vdev->wait_interrupt = 1;

		/* I've put it here to be sure that data is cleared */
		clear_data(vdev);

		fpi_ssm_next_state(ssm);
		break;

	case SSM_WAIT_INTERRUPT:
		/* Check if user had interrupted the process */
		if (!vdev->active) {
			libusb_cancel_transfer(vdev->transfer);
			fpi_ssm_jump_to_state(ssm, SSM_CLEAR_EP2);
			break;
		}

		if (vdev->wait_interrupt)
			fpi_timeout_add(VFS_SSM_TIMEOUT, wait_interrupt, ssm);
		break;

	case SSM_RECEIVE_FINGER:
		if (vdev->memory == 0) {
			/* Initialize fingerprint buffer */
			if (vdev->data != NULL)
				g_free(vdev->data);
			vdev->memory = VFS_USB_BUFFER_SIZE;
			vdev->data = g_malloc(vdev->memory);
			vdev->bytes = 0;

			/* Finger is on the scanner */
			fpi_imgdev_report_finger_status(idev, 1);
		}

		/* Increase buffer size while it's insufficient */
		while (vdev->bytes + VFS_USB_BUFFER_SIZE > vdev->memory) {
			vdev->memory <<= 1;
			vdev->data =
			    (unsigned char *)g_realloc(vdev->data,
						       vdev->memory);
		}

		/* Receive chunk of data */
		vdev->transfer = libusb_alloc_transfer(0);
		libusb_fill_bulk_transfer(vdev->transfer, udev, 0x82,
					  vdev->data + vdev->bytes,
					  VFS_USB_BUFFER_SIZE, receive_callback,
					  ssm, VFS_USB_TIMEOUT);
		libusb_submit_transfer(vdev->transfer);
		break;

	case SSM_SUBMIT_IMAGE:
		submit_image(idev);
		clear_data(vdev);

		/* Wait for probable vdev->active changing */
		fpi_timeout_add(VFS_SSM_TIMEOUT, scan_completed, ssm);
		break;

	case SSM_NEXT_RECEIVE:
		if (!vdev->active) {
			/* It's the last scan */
			fpi_ssm_jump_to_state(ssm, SSM_CLEAR_EP2);
			break;
		}

		/* Set control_packet argument */
		vdev->control_packet = next_receive_1;

		send_control_packet(ssm);
		break;

	case SSM_WAIT_ANOTHER_SCAN:
		/* Orange light is on now */
		fpi_timeout_add(VFS_SSM_ORANGE_TIMEOUT, another_scan, ssm);
		break;

	default:
		fp_err("Unknown state");
		fpi_imgdev_session_error(idev, -EIO);
		fpi_ssm_mark_aborted(ssm, -EIO);
	}
}

/* Driver functions */

/* Activate device */
static int dev_activate(struct fp_img_dev *idev, enum fp_imgdev_state state)
{
	struct vfs_dev_t *vdev = idev->priv;

	/* Initialize flags */
	vdev->active = 1;
	vdev->need_report = 1;

	struct fpi_ssm *ssm = fpi_ssm_new(idev->dev, activate_ssm, SSM_STATES);
	ssm->priv = idev;
	fpi_ssm_start(ssm, fpi_ssm_free);
	return 0;
}

/* Deactivate device */
static void dev_deactivate(struct fp_img_dev *idev)
{
	struct vfs_dev_t *vdev = idev->priv;

	/* Initialize flags */
	vdev->active = 0;
	vdev->need_report = 1;
}

/* Callback for dev_open ssm */
static void dev_open_callback(struct fpi_ssm *ssm)
{
	/* Notify open complete */
	fpi_imgdev_open_complete((struct fp_img_dev *)ssm->priv, 0);
	fpi_ssm_free(ssm);
}

/* Open device */
static int dev_open(struct fp_img_dev *idev, unsigned long driver_data)
{
	/* Claim usb interface */
	int error = libusb_claim_interface(idev->udev, 0);
	if (error < 0) {
		/* Interface not claimed, return error */
		fp_err("could not claim interface 0");
		return error;
	}

	/* Initialize private structure */
	struct vfs_dev_t *vdev = g_malloc0(sizeof(struct vfs_dev_t));
	idev->priv = vdev;

	/* Clearing previous device state */
	struct fpi_ssm *ssm = fpi_ssm_new(idev->dev, activate_ssm, SSM_STATES);
	ssm->priv = idev;
	fpi_ssm_start(ssm, dev_open_callback);
	return 0;
}

/* Close device */
static void dev_close(struct fp_img_dev *idev)
{
	/* Release private structure */
	g_free(idev->priv);

	/* Release usb interface */
	libusb_release_interface(idev->udev, 0);

	/* Notify close complete */
	fpi_imgdev_close_complete(idev);
}

/* Usb id table of device */
static const struct usb_id id_table[] = {
	{.vendor = 0x138a,.product = 0x0050},
	{0, 0, 0,},
};

/* Device driver definition */
struct fp_img_driver vfs0050_driver = {
	/* Driver specification */
	.driver = {
		   .id = VFS0050_ID,
		   .name = FP_COMPONENT,
		   .full_name = "Validity VFS0050",
		   .id_table = id_table,
		   .scan_type = FP_SCAN_TYPE_SWIPE,
		   },

	/* Image specification */
	.flags = 0,
	.img_width = VFS_RESULT_IMAGE_WIDTH,
	.img_height = -1,
	.bz3_threshold = 24,

	/* Routine specification */
	.open = dev_open,
	.close = dev_close,
	.activate = dev_activate,
	.deactivate = dev_deactivate,
};




/*
 * Validity VFS0050 driver for libfprint
 * Copyright (C) 2015 Konstantin Semenov <zemen17@gmail.com>
 *
 * 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
 */

/* Timeout for all send/recv operations, except interrupt waiting and abort */
#define VFS_USB_TIMEOUT 100
/* Timeout for usb abort */
#define VFS_USB_ABORT_TIMEOUT 20
/* Default timeout for SSM timers */
#define VFS_SSM_TIMEOUT 100
/* Timeout for orange light */
#define VFS_SSM_ORANGE_TIMEOUT 700

/* Buffer size for abort and fprint receiving */
#define VFS_USB_BUFFER_SIZE 65536

/* Do not touch this parameters! */

/* Width from scanner including extra data */
#define VFS_IMAGE_WIDTH 148
/* Only fprint image width from scanner */
#define VFS_RESULT_IMAGE_WIDTH 100
/* Maximum result image height */
#define VFS_MAX_HEIGHT 600
/* Size of control packets: turn_on, turn_off, next_receive_*  */
#define VFS_CONTROL_PACKET_SIZE 125
/* Size of result of commit */
#define VFS_COMMIT_RESPONSE_SIZE 1106
/* Size of interrupt from EP3 */
#define VFS_INTERRUPT_SIZE 5

/* Fingerprint horizontal line */
struct vfs_line {
	/* It must be always 0x01 */
	unsigned char _0x01;
	/* It must be always 0xfe */
	unsigned char _0xfe;

	/* line number starting from some number in Little-Endian */
	unsigned short id;

	/* Some hashes which are useful to detect noise */
	unsigned char noise_hash_1;
	unsigned char noise_hash_2;

	/* The first byte of _somedata is always 0x00, the second is strange useless cyclic line number */
	unsigned short _somedata;

	/* Fingerprint image */
	unsigned char data[VFS_RESULT_IMAGE_WIDTH];

	/* Narrow fingerprint part from the center, diagonally, currently it's skipped */
	unsigned char extra[32];

	/* scan_data is 0xfb except some rare cases, it seems that it's timeline but currently it's skipped too */
	unsigned char scan_data[8];
} __attribute__ ((__packed__));

/* The main driver structure */
struct vfs_dev_t {
	/* One if we were asked to read fingerprint, zero otherwise */
	char active;

	/* Control packet parameter for send_control_packet */
	unsigned char *control_packet;

	/* Current async transfer */
	struct libusb_transfer *transfer;

	/* Should we call fpi_imgdev_activate_complete or fpi_imgdev_deactivate_complete */
	char need_report;

	/* Should we wait more for interrupt */
	char wait_interrupt;

	/* Received fingerprint data */
	unsigned char *data;

	/* Current number of received bytes and current memory used by data */
	int bytes, memory;

	/* Received interrupt data */
	unsigned char interrupt[8];
};

/* SSM states for clear_ep2 */
enum SUBSM1 {
	SUBSM1_COMMAND_04,
	SUBSM1_RETURN_CODE,
	SUBSM1_ABORT_2,

	SUBSM1_STATES,
};

/* SSM states for control */
enum SUBSM2 {
	SUBSM2_SEND_CONTROL,
	SUBSM2_RETURN_CODE,	/* If next_receive, send another control packet */

	SUBSM2_SEND_COMMIT,
	SUBSM2_COMMIT_RESPONSE,
	SUBSM2_READ_EMPTY_INTERRUPT,
	SUBSM2_ABORT_3,
	SUBSM2_CLEAR_EP2,

	SUBSM2_STATES,
};

/* SSM states for activate_ssm */
enum SSM_STATE {
	SSM_INITIAL_ABORT_1,
	SSM_INITIAL_ABORT_2,
	SSM_INITIAL_ABORT_3,
	SSM_CLEAR_EP2,
	SSM_TURN_OFF,

	/* Here the device is turned off; if not active, complete ssm */
	SSM_TURN_ON,

	SSM_ASK_INTERRUPT,
	SSM_WAIT_INTERRUPT,

	SSM_RECEIVE_FINGER,
	SSM_SUBMIT_IMAGE,

	/* If not active, jump to CLEAR_EP2 */
	SSM_NEXT_RECEIVE,
	SSM_WAIT_ANOTHER_SCAN,
	/* Jump to TURN_ON */

	SSM_STATES
};

/* Blocks of data from USB sniffer */

/* Turns on the light */
static unsigned char turn_on[] = {
	0x39, 0x20, 0xBF, 0x02, 0x00, 0xF4, 0x01, 0x00, 0x00, 0x01, 0xD1, 0x00,
	    0x20, 0xD1, 0xD1, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF4, 0x01, 0x00,
	    0x00, 0x01, 0x00, 0x00,
	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0xF4, 0x01, 0x00,
	0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0xF4, 0x01, 0x00, 0x00, 0x02, 0xD1, 0x00, 0x20, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00,
};

/* Power off */
static unsigned char turn_off[] = {
	0x39, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00,
};

/* Turns on orange light */
static unsigned char next_receive_1[] = {
	0x39, 0xB8, 0x0B, 0x00, 0x00, 0xB8, 0x0B, 0x00, 0x00, 0x01, 0xD1, 0x00,
	    0x20, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0xD1, 0xD1, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x01, 0x00, 0x00,
	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0xB8, 0x0B, 0x00, 0x00, 0x02, 0xD1, 0x00, 0x20, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00,
};

/* Packet directly after next_receive_1 */
static unsigned char next_receive_2[] = {
	0x39, 0xE8, 0x03, 0x00, 0x00, 0xE8, 0x03, 0x00, 0x00, 0x01, 0xD1, 0x00,
	    0x20, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0xD1, 0xD1, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x01, 0x00, 0x00,
	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0xE8, 0x03, 0x00, 0x00, 0x02, 0xD1, 0x00, 0x20, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00,
};

/* Commit message */
static unsigned char commit_out[] = {
	0x02, 0x94, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x2C, 0x03, 0x00,
	    0x30, 0x1B, 0x00, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x20, 0x03, 0x00, 0x30, 0x3D, 0x10, 0x00,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x18, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x24, 0x03, 0x00,
	0x30, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x28, 0x03, 0x00,
	    0x30, 0x08, 0x00, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x30, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x38, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x3C, 0x03, 0x00,
	0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x44, 0x03, 0x00,
	    0x30, 0x14, 0x00, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x48, 0x03, 0x00, 0x30, 0x01, 0x04, 0x02,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x4C, 0x03, 0x00, 0x30, 0x01, 0x0C, 0x02, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x54, 0x03, 0x00,
	0x30, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x5C, 0x03, 0x00,
	    0x30, 0x90, 0x01, 0x02,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x60, 0x03, 0x00, 0x30, 0x2C, 0x01, 0x19,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x64, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x6C, 0x03, 0x00,
	0x30, 0x1E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x70, 0x03, 0x00,
	    0x30, 0x21, 0x80, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x78, 0x03, 0x00, 0x30, 0x09, 0x00, 0x02,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x7C, 0x03, 0x00, 0x30, 0x0B, 0x00, 0x19, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x80, 0x03, 0x00,
	0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x84, 0x03, 0x00,
	    0x30, 0x3A, 0x00, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x88, 0x03, 0x00, 0x30, 0x14, 0x00, 0x00,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x8C, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x90, 0x03, 0x00,
	0x30, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x94, 0x03, 0x00,
	    0x30, 0x08, 0x00, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x98, 0x03, 0x00, 0x30, 0x00, 0x00, 0xA1,
	    0x01, 0x20, 0x00, 0x08,
	0x00, 0x9C, 0x03, 0x00, 0x30, 0x00, 0x00, 0xA1, 0x01, 0x20, 0x00, 0x08,
	    0x00, 0xA8, 0x03, 0x00,
	0x30, 0x64, 0x01, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0xAC, 0x03, 0x00,
	    0x30, 0x64, 0x01, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0xB0, 0x03, 0x00, 0x30, 0x00, 0x01, 0x00,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0xB4, 0x03, 0x00, 0x30, 0x00, 0x01, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0xB8, 0x03, 0x00,
	0x30, 0x05, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0xBC, 0x03, 0x00,
	    0x30, 0x05, 0x00, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0xC0, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x84, 0x03, 0x00, 0x30, 0x3B, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x08, 0x07, 0x00,
	0x30, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x0C, 0x07, 0x00,
	    0x30, 0x00, 0x00, 0x00,
	0x00, 0x20, 0x00, 0x08, 0x00, 0x14, 0x07, 0x00, 0x30, 0x20, 0x00, 0x00,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x1C, 0x07, 0x00, 0x30, 0x1A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x70, 0x0D, 0x00,
	0x30, 0x01, 0x00, 0x00, 0x00, 0x25, 0x00, 0x28, 0x00, 0x10, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x02, 0x00, 0x90, 0x00, 0x00, 0x00, 0x2B, 0xFF, 0x2B, 0xFF, 0x2B,
	    0xED, 0x00, 0x00, 0x2B,
	0xFB, 0x00, 0x00, 0x2B, 0xC5, 0x00, 0x00, 0x2B, 0x05, 0x80, 0x70, 0x00,
	    0x00, 0x00, 0x00, 0x00,
	0x00, 0x24, 0xD3, 0x2E, 0xC0, 0x2C, 0x3B, 0x08, 0xF0, 0x3B, 0x09, 0x24,
	    0xBB, 0x3B, 0x0B, 0x24,
	0xAA, 0x3B, 0x1F, 0xF8, 0x00, 0x3B, 0x3F, 0xF0, 0x00, 0x3B, 0x35, 0xC0,
	    0x00, 0x38, 0x80, 0x2C,
	0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x38, 0x80, 0x2C, 0x70, 0x00,
	    0x00, 0x00, 0x00, 0xC0,
	0x3A, 0x80, 0x2C, 0x70, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x3B, 0x0A, 0x80,
	    0x2E, 0x83, 0x24, 0xDB,
	0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x2C, 0x31, 0x83, 0x2C, 0x70,
	    0x00, 0x00, 0x00, 0x00,
	0xCB, 0x33, 0x1B, 0x83, 0x2C, 0x70, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x31,
	    0x83, 0x2C, 0x70, 0x00,
	0x00, 0x00, 0x00, 0xCB, 0x00, 0x33, 0x1E, 0x83, 0x2E, 0x25, 0xFF, 0xC4,
	    0x00, 0x2F, 0x06, 0x84,
	0x2E, 0x00, 0x00, 0x10, 0x20, 0x29, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00,
	    0x00, 0x23, 0x00, 0x00,
	0x00, 0x21, 0x00, 0x10, 0x00, 0x48, 0x03, 0x00, 0x30, 0xFF, 0xF0, 0xFF,
	    0xFF, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x04, 0x00, 0x00, 0x21, 0x00, 0x10, 0x00, 0x4C, 0x03, 0x00,
	    0x30, 0xFF, 0xF0, 0xFF,
	0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x21, 0x00, 0x10,
	    0x00, 0x20, 0x03, 0x00,
	0x30, 0x7F, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x80, 0x10, 0x00,
	    0x00, 0x20, 0x00, 0x08,
	0x00, 0x24, 0x03, 0x00, 0x30, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x1C, 0x07, 0x00,
	0x30, 0x1A, 0x00, 0x00, 0x00, 0x21, 0x00, 0x10, 0x00, 0x20, 0x03, 0x00,
	    0x30, 0xC3, 0xFF, 0xFF,
	0xFF, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
	    0x00, 0x80, 0x03, 0x00,
	0x30, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x84, 0x00, 0x31, 0x65, 0x77,
	    0x77, 0x77, 0x78, 0x88,
	0x77, 0x77, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x77, 0x67,
	    0x66, 0x66, 0x66, 0x66,
	0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x76, 0x67, 0x66, 0x66, 0x66, 0x66,
	    0x66, 0x77, 0x66, 0x66,
	0x66, 0x66, 0x67, 0x66, 0x66, 0x66, 0x66, 0x66, 0x76, 0x76, 0x66, 0x56,
	    0x66, 0x66, 0x56, 0x55,
	0x65, 0x66, 0x66, 0x66, 0x65, 0x66, 0x66, 0x55, 0x66, 0x66, 0x65, 0x66,
	    0x76, 0x76, 0x77, 0x77,
	0x66, 0x66, 0x66, 0x76, 0x67, 0x66, 0x77, 0x67, 0x66, 0x66, 0x66, 0x56,
	    0x65, 0x66, 0x65, 0x66,
	0x66, 0x55, 0x55, 0x54, 0x55, 0x65, 0x66, 0x66, 0x66, 0x76, 0x77, 0x87,
	    0x88, 0x77, 0x66, 0x66,
	0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x66, 0x55, 0x55, 0x65, 0x56, 0x55,
	    0x55, 0x55, 0x54, 0x45,
	0x54, 0x55, 0x55, 0x55, 0x66, 0x66, 0x66, 0x66, 0x66, 0x77, 0x77, 0x77,
	    0x66, 0x26, 0x00, 0x28,
	0x00, 0xFF, 0x00, 0x0F, 0x00, 0xF0, 0xF0, 0x0F, 0x00, 0x20, 0x00, 0x00,
	    0x00, 0x30, 0x01, 0x02,
	0x00, 0x2C, 0x01, 0x28, 0x00, 0x20, 0x80, 0x00, 0x00, 0x0A, 0x00, 0x02,
	    0x00, 0x0B, 0x00, 0x19,
	0x00, 0x40, 0x1F, 0x10, 0x27, 0x00, 0x0F, 0x03, 0x00,
};

/* Known interrupts */

static unsigned char empty_interrupt[] = {
	0x00, 0x00, 0x00, 0x00, 0x00,
};

static unsigned char interrupt1[] = {
	0x02, 0x00, 0x0E, 0x00, 0xF0,
};

static unsigned char interrupt2[] = {
	0x02, 0x04, 0x0A, 0x00, 0xF0,
};

static unsigned char interrupt3[] = {
	0x02, 0x00, 0x0A, 0x00, 0xF0,
};

Lines 305-310 extern struct fp_img_driver upektc_img_driver; Link Here

(-)a/libfprint/fp_internal.h (+4 lines)
305	#ifdef ENABLE_ETES603	305	#ifdef ENABLE_ETES603
306	extern struct fp_img_driver etes603_driver;	306	extern struct fp_img_driver etes603_driver;
307	#endif	307	#endif
		308	#ifdef ENABLE_VFS0050
		309	extern struct fp_img_driver vfs0050_driver;
		310	#endif
308		311
309	extern libusb_context *fpi_usb_ctx;	312	extern libusb_context *fpi_usb_ctx;
310	extern GSList *opened_devices;	313	extern GSList *opened_devices;
Lines 402-407 int fpi_img_compare_print_data(struct fp_print_data *enrolled_print, Link Here
402	int fpi_img_compare_print_data_to_gallery(struct fp_print_data *print,	405	int fpi_img_compare_print_data_to_gallery(struct fp_print_data *print,
403	struct fp_print_data *gallery, int match_threshold, size_t match_offset);	406	struct fp_print_data *gallery, int match_threshold, size_t match_offset);
404	struct fp_img fpi_im_resize(struct fp_img img, unsigned int w_factor, unsigned int h_factor);	407	struct fp_img fpi_im_resize(struct fp_img img, unsigned int w_factor, unsigned int h_factor);
		408	void fpi_im_downscale(struct fp_img *img, double w_factor, double h_factor);
405		409
406	/* polling and timeouts */	410	/* polling and timeouts */
407		411

Lines 74-80 static void print_driver (struct fp_driver *driver) Link Here

(-)a/libfprint/fprint-list-udev-rules.c (-1 / +2 lines)
74	if (num_printed == 0)	74	if (num_printed == 0)
75	printf ("# %s\n", driver->full_name);	75	printf ("# %s\n", driver->full_name);
76		76
77	printf ("SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"%04x\", ATTRS{idProduct}==\"%04x\", ATTRS{dev}==\"*\", TEST==\"power/control\", ATTR{power/control}=\"auto\"\n", driver->id_table[i].vendor, driver->id_table[i].product);	77	printf ("SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"%04x\", ATTRS{idProduct}==\"%04x\", ATTRS{dev}==\"*\", TEST==\"power/control\", ATTR{power/control}=\"auto\"\n, MODE=\"0666\"\n", driver->id_table[i].vendor, driver->id_table[i].product);
		78	printf ("SUBSYSTEM==\"usb\", ATTRS{idVendor}==\"%04x\", ATTRS{idProduct}==\"%04x\", ENV{LIBFPRINT_DRIVER}=\"%s\"\n", driver->id_table[i].vendor, driver->id_table[i].product, driver->full_name);
78	num_printed++;	79	num_printed++;
79	}	80	}
80		81

Lines 165-170 void fpi_imgdev_report_finger_status(struct fp_img_dev *imgdev, Link Here

(-)a/libfprint/imgdev.c (+9 lines)
165	case IMG_ACTION_VERIFY:	165	case IMG_ACTION_VERIFY:
166	fpi_drvcb_report_verify_result(imgdev->dev, r, img);	166	fpi_drvcb_report_verify_result(imgdev->dev, r, img);
167	fp_print_data_free(data);	167	fp_print_data_free(data);
		168
		169	/* the callback can cancel verifying, so recheck current
		170	* action and the status to see if retry is needed */
		171	if (imgdev->action == IMG_ACTION_VERIFY &&
		172	r > 0 && r != FP_VERIFY_MATCH && r != FP_VERIFY_NO_MATCH) {
		173	imgdev->action_result = 0;
		174	imgdev->action_state = IMG_ACQUIRE_STATE_AWAIT_FINGER_ON;
		175	dev_change_state(imgdev, IMGDEV_STATE_AWAIT_FINGER_ON);
		176	}
168	break;	177	break;
169	case IMG_ACTION_IDENTIFY:	178	case IMG_ACTION_IDENTIFY:
170	fpi_drvcb_report_identify_result(imgdev->dev, r,	179	fpi_drvcb_report_identify_result(imgdev->dev, r,




	return newimg;
}

void fpi_im_downscale(struct fp_img *img, double w_factor, double h_factor)
{
	int new_width = img->width * w_factor;
	int new_height = img->height * h_factor;

	pixman_image_t *orig, *resized;
	pixman_transform_t transform;

	orig = pixman_image_create_bits(PIXMAN_a8, img->width, img->height, (uint32_t *)img->data, img->width);
	resized = pixman_image_create_bits(PIXMAN_a8, new_width, new_height, NULL, new_width);

	pixman_transform_init_identity(&transform);
	pixman_transform_scale(NULL, &transform, pixman_double_to_fixed(w_factor), pixman_double_to_fixed(h_factor));
	pixman_image_set_transform(orig, &transform);
	pixman_image_set_filter(orig, PIXMAN_FILTER_BEST, NULL, 0);
	pixman_image_composite32(PIXMAN_OP_SRC,
		orig, /* src */
		NULL, /* mask */
		resized, /* dst */
		0, 0, /* src x y */
		0, 0, /* mask x y */
		0, 0, /* dst x y */
		new_width, new_height /* width height */
		);

    fpi_img_resize(img, new_width * new_height);
	img->width = new_width;
	img->height = new_height;

	memcpy(img->data, pixman_image_get_data(resized), new_width * new_height);

	pixman_image_unref(orig);
	pixman_image_unref(resized);
}


Return to bug 531698

Line 0 Link Here

(-)a/libfprint/drivers/vfs0050.h (+374 lines)
		1	/*
		2	* Validity VFS0050 driver for libfprint
		3	* Copyright (C) 2015 Konstantin Semenov <zemen17@gmail.com>
		4	*
		5	* This library is free software; you can redistribute it and/or
		6	* modify it under the terms of the GNU Lesser General Public
		7	* License as published by the Free Software Foundation; either
		8	* version 2.1 of the License, or (at your option) any later version.
		9	*
		10	* This library is distributed in the hope that it will be useful,
		11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		13	* Lesser General Public License for more details.
		14	*
		15	* You should have received a copy of the GNU Lesser General Public
		16	* License along with this library; if not, write to the Free Software
		17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		18	*/
		19
		20	/* Timeout for all send/recv operations, except interrupt waiting and abort */
		21	#define VFS_USB_TIMEOUT 100
		22	/* Timeout for usb abort */
		23	#define VFS_USB_ABORT_TIMEOUT 20
		24	/* Default timeout for SSM timers */
		25	#define VFS_SSM_TIMEOUT 100
		26	/* Timeout for orange light */
		27	#define VFS_SSM_ORANGE_TIMEOUT 700
		28
		29	/* Buffer size for abort and fprint receiving */
		30	#define VFS_USB_BUFFER_SIZE 65536
		31
		32	/* Do not touch this parameters! */
		33
		34	/* Width from scanner including extra data */
		35	#define VFS_IMAGE_WIDTH 148
		36	/* Only fprint image width from scanner */
		37	#define VFS_RESULT_IMAGE_WIDTH 100
		38	/* Maximum result image height */
		39	#define VFS_MAX_HEIGHT 600
		40	/* Size of control packets: turn_on, turn_off, next_receive_* */
		41	#define VFS_CONTROL_PACKET_SIZE 125
		42	/* Size of result of commit */
		43	#define VFS_COMMIT_RESPONSE_SIZE 1106
		44	/* Size of interrupt from EP3 */
		45	#define VFS_INTERRUPT_SIZE 5
		46
		47	/* Fingerprint horizontal line */
		48	struct vfs_line {
		49	/* It must be always 0x01 */
		50	unsigned char _0x01;
		51	/* It must be always 0xfe */
		52	unsigned char _0xfe;
		53
		54	/* line number starting from some number in Little-Endian */
		55	unsigned short id;
		56
		57	/* Some hashes which are useful to detect noise */
		58	unsigned char noise_hash_1;
		59	unsigned char noise_hash_2;
		60
		61	/* The first byte of _somedata is always 0x00, the second is strange useless cyclic line number */
		62	unsigned short _somedata;
		63
		64	/* Fingerprint image */
65	unsigned char data[VFS_RESULT_IMAGE_WIDTH];
66
67	/* Narrow fingerprint part from the center, diagonally, currently it's skipped */
68	unsigned char extra[32];
69
70	/* scan_data is 0xfb except some rare cases, it seems that it's timeline but currently it's skipped too */
71	unsigned char scan_data[8];
72	} __attribute__ ((__packed__));
73
74	/* The main driver structure */
75	struct vfs_dev_t {
76	/* One if we were asked to read fingerprint, zero otherwise */
77	char active;
78
79	/* Control packet parameter for send_control_packet */
80	unsigned char *control_packet;
81
82	/* Current async transfer */
83	struct libusb_transfer *transfer;
84
85	/* Should we call fpi_imgdev_activate_complete or fpi_imgdev_deactivate_complete */
86	char need_report;
87
88	/* Should we wait more for interrupt */
89	char wait_interrupt;
90
91	/* Received fingerprint data */
92	unsigned char *data;
93
94	/* Current number of received bytes and current memory used by data */
95	int bytes, memory;
96
97	/* Received interrupt data */
98	unsigned char interrupt[8];
99	};
100
101	/* SSM states for clear_ep2 */
102	enum SUBSM1 {
103	SUBSM1_COMMAND_04,
104	SUBSM1_RETURN_CODE,
105	SUBSM1_ABORT_2,
106
107	SUBSM1_STATES,
108	};
109
110	/* SSM states for control */
111	enum SUBSM2 {
112	SUBSM2_SEND_CONTROL,
113	SUBSM2_RETURN_CODE, /* If next_receive, send another control packet */
114
115	SUBSM2_SEND_COMMIT,
116	SUBSM2_COMMIT_RESPONSE,
117	SUBSM2_READ_EMPTY_INTERRUPT,
118	SUBSM2_ABORT_3,
119	SUBSM2_CLEAR_EP2,
120
121	SUBSM2_STATES,
122	};
123
124	/* SSM states for activate_ssm */
125	enum SSM_STATE {
126	SSM_INITIAL_ABORT_1,
127	SSM_INITIAL_ABORT_2,
128	SSM_INITIAL_ABORT_3,
129	SSM_CLEAR_EP2,
130	SSM_TURN_OFF,
131
132	/* Here the device is turned off; if not active, complete ssm */
133	SSM_TURN_ON,
134
135	SSM_ASK_INTERRUPT,
136	SSM_WAIT_INTERRUPT,
137
138	SSM_RECEIVE_FINGER,
139	SSM_SUBMIT_IMAGE,
140
141	/* If not active, jump to CLEAR_EP2 */
142	SSM_NEXT_RECEIVE,
143	SSM_WAIT_ANOTHER_SCAN,
144	/* Jump to TURN_ON */
145
146	SSM_STATES
147	};
148
149	/* Blocks of data from USB sniffer */
150
151	/* Turns on the light */
152	static unsigned char turn_on[] = {
153	0x39, 0x20, 0xBF, 0x02, 0x00, 0xF4, 0x01, 0x00, 0x00, 0x01, 0xD1, 0x00,
154	0x20, 0xD1, 0xD1, 0x00,
155	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF4, 0x01, 0x00,
156	0x00, 0x01, 0x00, 0x00,
157	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
158	0x00, 0xF4, 0x01, 0x00,
159	0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
160	0x00, 0x00, 0x00, 0x00,
161	0x00, 0xF4, 0x01, 0x00, 0x00, 0x02, 0xD1, 0x00, 0x20, 0x00, 0x00, 0x00,
162	0x00, 0x00, 0x00, 0x00,
163	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
164	0x00, 0x00, 0x00, 0x00,
165	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
166	0x00, 0x00, 0x00, 0x00,
167	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
168	0x00,
169	};
170
171	/* Power off */
172	static unsigned char turn_off[] = {
173	0x39, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
174	0x00, 0x00, 0x00, 0x00,
175	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
176	0x00, 0x00, 0x00, 0x00,
177	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
178	0x00, 0x00, 0x00, 0x00,
179	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
180	0x00, 0x00, 0x00, 0x00,
181	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
182	0x00, 0x00, 0x00, 0x00,
183	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
184	0x00, 0x00, 0x00, 0x00,
185	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
186	0x00, 0x00, 0x00, 0x00,
187	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
188	0x00,
189	};
190
191	/* Turns on orange light */
192	static unsigned char next_receive_1[] = {
193	0x39, 0xB8, 0x0B, 0x00, 0x00, 0xB8, 0x0B, 0x00, 0x00, 0x01, 0xD1, 0x00,
194	0x20, 0x00, 0x00, 0x00,
195	0x00, 0x00, 0x00, 0x00, 0x00, 0xD1, 0xD1, 0x00, 0x00, 0x00, 0x00, 0x00,
196	0x00, 0x01, 0x00, 0x00,
197	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
198	0x00, 0x00, 0x00, 0x00,
199	0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
200	0x00, 0x00, 0x00, 0x00,
201	0x00, 0xB8, 0x0B, 0x00, 0x00, 0x02, 0xD1, 0x00, 0x20, 0x00, 0x00, 0x00,
202	0x00, 0x00, 0x00, 0x00,
203	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
204	0x00, 0x00, 0x00, 0x00,
205	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
206	0x00, 0x00, 0x00, 0x00,
207	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
208	0x00,
209	};
210
211	/* Packet directly after next_receive_1 */
212	static unsigned char next_receive_2[] = {
213	0x39, 0xE8, 0x03, 0x00, 0x00, 0xE8, 0x03, 0x00, 0x00, 0x01, 0xD1, 0x00,
214	0x20, 0x00, 0x00, 0x00,
215	0x00, 0x00, 0x00, 0x00, 0x00, 0xD1, 0xD1, 0x00, 0x00, 0x00, 0x00, 0x00,
216	0x00, 0x01, 0x00, 0x00,
217	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
218	0x00, 0x00, 0x00, 0x00,
219	0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
220	0x00, 0x00, 0x00, 0x00,
221	0x00, 0xE8, 0x03, 0x00, 0x00, 0x02, 0xD1, 0x00, 0x20, 0x00, 0x00, 0x00,
222	0x00, 0x00, 0x00, 0x00,
223	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
224	0x00, 0x00, 0x00, 0x00,
225	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
226	0x00, 0x00, 0x00, 0x00,
227	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
228	0x00,
229	};
230
231	/* Commit message */
232	static unsigned char commit_out[] = {
233	0x02, 0x94, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x2C, 0x03, 0x00,
234	0x30, 0x1B, 0x00, 0x00,
235	0x00, 0x20, 0x00, 0x08, 0x00, 0x20, 0x03, 0x00, 0x30, 0x3D, 0x10, 0x00,
236	0x00, 0x20, 0x00, 0x08,
237	0x00, 0x18, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
238	0x00, 0x24, 0x03, 0x00,
239	0x30, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x28, 0x03, 0x00,
240	0x30, 0x08, 0x00, 0x00,
241	0x00, 0x20, 0x00, 0x08, 0x00, 0x30, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00,
242	0x00, 0x20, 0x00, 0x08,
243	0x00, 0x38, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
244	0x00, 0x3C, 0x03, 0x00,
245	0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x44, 0x03, 0x00,
246	0x30, 0x14, 0x00, 0x00,
247	0x00, 0x20, 0x00, 0x08, 0x00, 0x48, 0x03, 0x00, 0x30, 0x01, 0x04, 0x02,
248	0x00, 0x20, 0x00, 0x08,
249	0x00, 0x4C, 0x03, 0x00, 0x30, 0x01, 0x0C, 0x02, 0x00, 0x20, 0x00, 0x08,
250	0x00, 0x54, 0x03, 0x00,
251	0x30, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x5C, 0x03, 0x00,
252	0x30, 0x90, 0x01, 0x02,
253	0x00, 0x20, 0x00, 0x08, 0x00, 0x60, 0x03, 0x00, 0x30, 0x2C, 0x01, 0x19,
254	0x00, 0x20, 0x00, 0x08,
255	0x00, 0x64, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
256	0x00, 0x6C, 0x03, 0x00,
257	0x30, 0x1E, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x70, 0x03, 0x00,
258	0x30, 0x21, 0x80, 0x00,
259	0x00, 0x20, 0x00, 0x08, 0x00, 0x78, 0x03, 0x00, 0x30, 0x09, 0x00, 0x02,
260	0x00, 0x20, 0x00, 0x08,
261	0x00, 0x7C, 0x03, 0x00, 0x30, 0x0B, 0x00, 0x19, 0x00, 0x20, 0x00, 0x08,
262	0x00, 0x80, 0x03, 0x00,
263	0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x84, 0x03, 0x00,
264	0x30, 0x3A, 0x00, 0x00,
265	0x00, 0x20, 0x00, 0x08, 0x00, 0x88, 0x03, 0x00, 0x30, 0x14, 0x00, 0x00,
266	0x00, 0x20, 0x00, 0x08,
267	0x00, 0x8C, 0x03, 0x00, 0x30, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
268	0x00, 0x90, 0x03, 0x00,
269	0x30, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x94, 0x03, 0x00,
270	0x30, 0x08, 0x00, 0x00,
271	0x00, 0x20, 0x00, 0x08, 0x00, 0x98, 0x03, 0x00, 0x30, 0x00, 0x00, 0xA1,
272	0x01, 0x20, 0x00, 0x08,
273	0x00, 0x9C, 0x03, 0x00, 0x30, 0x00, 0x00, 0xA1, 0x01, 0x20, 0x00, 0x08,
274	0x00, 0xA8, 0x03, 0x00,
275	0x30, 0x64, 0x01, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0xAC, 0x03, 0x00,
276	0x30, 0x64, 0x01, 0x00,
277	0x00, 0x20, 0x00, 0x08, 0x00, 0xB0, 0x03, 0x00, 0x30, 0x00, 0x01, 0x00,
278	0x00, 0x20, 0x00, 0x08,
279	0x00, 0xB4, 0x03, 0x00, 0x30, 0x00, 0x01, 0x00, 0x00, 0x20, 0x00, 0x08,
280	0x00, 0xB8, 0x03, 0x00,
281	0x30, 0x05, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0xBC, 0x03, 0x00,
282	0x30, 0x05, 0x00, 0x00,
283	0x00, 0x20, 0x00, 0x08, 0x00, 0xC0, 0x03, 0x00, 0x30, 0x00, 0x00, 0x00,
284	0x00, 0x20, 0x00, 0x08,
285	0x00, 0x84, 0x03, 0x00, 0x30, 0x3B, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
286	0x00, 0x08, 0x07, 0x00,
287	0x30, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x0C, 0x07, 0x00,
288	0x30, 0x00, 0x00, 0x00,
289	0x00, 0x20, 0x00, 0x08, 0x00, 0x14, 0x07, 0x00, 0x30, 0x20, 0x00, 0x00,
290	0x00, 0x20, 0x00, 0x08,
291	0x00, 0x1C, 0x07, 0x00, 0x30, 0x1A, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
292	0x00, 0x70, 0x0D, 0x00,
293	0x30, 0x01, 0x00, 0x00, 0x00, 0x25, 0x00, 0x28, 0x00, 0x10, 0x00, 0x00,
294	0x00, 0x00, 0x00, 0x00,
295	0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
296	0x00, 0x00, 0x00, 0x00,
297	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
298	0x00, 0x00, 0x00, 0x00,
299	0x00, 0x02, 0x00, 0x90, 0x00, 0x00, 0x00, 0x2B, 0xFF, 0x2B, 0xFF, 0x2B,
300	0xED, 0x00, 0x00, 0x2B,
301	0xFB, 0x00, 0x00, 0x2B, 0xC5, 0x00, 0x00, 0x2B, 0x05, 0x80, 0x70, 0x00,
302	0x00, 0x00, 0x00, 0x00,
303	0x00, 0x24, 0xD3, 0x2E, 0xC0, 0x2C, 0x3B, 0x08, 0xF0, 0x3B, 0x09, 0x24,
304	0xBB, 0x3B, 0x0B, 0x24,
305	0xAA, 0x3B, 0x1F, 0xF8, 0x00, 0x3B, 0x3F, 0xF0, 0x00, 0x3B, 0x35, 0xC0,
306	0x00, 0x38, 0x80, 0x2C,
307	0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x38, 0x80, 0x2C, 0x70, 0x00,
308	0x00, 0x00, 0x00, 0xC0,
309	0x3A, 0x80, 0x2C, 0x70, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x3B, 0x0A, 0x80,
310	0x2E, 0x83, 0x24, 0xDB,
311	0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x2C, 0x31, 0x83, 0x2C, 0x70,
312	0x00, 0x00, 0x00, 0x00,
313	0xCB, 0x33, 0x1B, 0x83, 0x2C, 0x70, 0x00, 0x00, 0x00, 0x00, 0xCB, 0x31,
314	0x83, 0x2C, 0x70, 0x00,
315	0x00, 0x00, 0x00, 0xCB, 0x00, 0x33, 0x1E, 0x83, 0x2E, 0x25, 0xFF, 0xC4,
316	0x00, 0x2F, 0x06, 0x84,
317	0x2E, 0x00, 0x00, 0x10, 0x20, 0x29, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00,
318	0x00, 0x23, 0x00, 0x00,
319	0x00, 0x21, 0x00, 0x10, 0x00, 0x48, 0x03, 0x00, 0x30, 0xFF, 0xF0, 0xFF,
320	0xFF, 0x00, 0x00, 0x00,
321	0x00, 0x00, 0x04, 0x00, 0x00, 0x21, 0x00, 0x10, 0x00, 0x4C, 0x03, 0x00,
322	0x30, 0xFF, 0xF0, 0xFF,
323	0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x21, 0x00, 0x10,
324	0x00, 0x20, 0x03, 0x00,
325	0x30, 0x7F, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x80, 0x10, 0x00,
326	0x00, 0x20, 0x00, 0x08,
327	0x00, 0x24, 0x03, 0x00, 0x30, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
328	0x00, 0x1C, 0x07, 0x00,
329	0x30, 0x1A, 0x00, 0x00, 0x00, 0x21, 0x00, 0x10, 0x00, 0x20, 0x03, 0x00,
330	0x30, 0xC3, 0xFF, 0xFF,
331	0xFF, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08,
332	0x00, 0x80, 0x03, 0x00,
333	0x30, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x84, 0x00, 0x31, 0x65, 0x77,
334	0x77, 0x77, 0x78, 0x88,
335	0x77, 0x77, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x77, 0x67,
336	0x66, 0x66, 0x66, 0x66,
337	0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x76, 0x67, 0x66, 0x66, 0x66, 0x66,
338	0x66, 0x77, 0x66, 0x66,
339	0x66, 0x66, 0x67, 0x66, 0x66, 0x66, 0x66, 0x66, 0x76, 0x76, 0x66, 0x56,
340	0x66, 0x66, 0x56, 0x55,
341	0x65, 0x66, 0x66, 0x66, 0x65, 0x66, 0x66, 0x55, 0x66, 0x66, 0x65, 0x66,
342	0x76, 0x76, 0x77, 0x77,
343	0x66, 0x66, 0x66, 0x76, 0x67, 0x66, 0x77, 0x67, 0x66, 0x66, 0x66, 0x56,
344	0x65, 0x66, 0x65, 0x66,
345	0x66, 0x55, 0x55, 0x54, 0x55, 0x65, 0x66, 0x66, 0x66, 0x76, 0x77, 0x87,
346	0x88, 0x77, 0x66, 0x66,
347	0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x66, 0x55, 0x55, 0x65, 0x56, 0x55,
348	0x55, 0x55, 0x54, 0x45,
349	0x54, 0x55, 0x55, 0x55, 0x66, 0x66, 0x66, 0x66, 0x66, 0x77, 0x77, 0x77,
350	0x66, 0x26, 0x00, 0x28,
351	0x00, 0xFF, 0x00, 0x0F, 0x00, 0xF0, 0xF0, 0x0F, 0x00, 0x20, 0x00, 0x00,
352	0x00, 0x30, 0x01, 0x02,
353	0x00, 0x2C, 0x01, 0x28, 0x00, 0x20, 0x80, 0x00, 0x00, 0x0A, 0x00, 0x02,
354	0x00, 0x0B, 0x00, 0x19,
355	0x00, 0x40, 0x1F, 0x10, 0x27, 0x00, 0x0F, 0x03, 0x00,
356	};
357
358	/* Known interrupts */
359
360	static unsigned char empty_interrupt[] = {
361	0x00, 0x00, 0x00, 0x00, 0x00,
362	};
363
364	static unsigned char interrupt1[] = {
365	0x02, 0x00, 0x0E, 0x00, 0xF0,
366	};
367
368	static unsigned char interrupt2[] = {
369	0x02, 0x04, 0x0A, 0x00, 0xF0,
370	};
371
372	static unsigned char interrupt3[] = {
373	0x02, 0x00, 0x0A, 0x00, 0xF0,
374	};

Lines 61-63 struct fp_img fpi_im_resize(struct fp_img img, unsigned int w_factor, unsigned Link Here

(-)a/libfprint/pixman.c (+35 lines)
61	return newimg;	61	return newimg;
62	}	62	}
63		63
		64	void fpi_im_downscale(struct fp_img *img, double w_factor, double h_factor)
		65	{
		66	int new_width = img->width * w_factor;
		67	int new_height = img->height * h_factor;
		68
		69	pixman_image_t orig, resized;
		70	pixman_transform_t transform;
		71
		72	orig = pixman_image_create_bits(PIXMAN_a8, img->width, img->height, (uint32_t *)img->data, img->width);
		73	resized = pixman_image_create_bits(PIXMAN_a8, new_width, new_height, NULL, new_width);
		74
		75	pixman_transform_init_identity(&transform);
		76	pixman_transform_scale(NULL, &transform, pixman_double_to_fixed(w_factor), pixman_double_to_fixed(h_factor));
		77	pixman_image_set_transform(orig, &transform);
		78	pixman_image_set_filter(orig, PIXMAN_FILTER_BEST, NULL, 0);
		79	pixman_image_composite32(PIXMAN_OP_SRC,
		80	orig, /* src */
		81	NULL, /* mask */
		82	resized, /* dst */
		83	0, 0, /* src x y */
		84	0, 0, /* mask x y */
		85	0, 0, /* dst x y */
		86	new_width, new_height /* width height */
		87	);
		88
		89	fpi_img_resize(img, new_width * new_height);
		90	img->width = new_width;
		91	img->height = new_height;
		92
		93	memcpy(img->data, pixman_image_get_data(resized), new_width * new_height);
		94
		95	pixman_image_unref(orig);
		96	pixman_image_unref(resized);
		97	}
		98