Attachment 76751 Details for Bug 60445 – 0001-Implement-image-capture-both-synchronous-and-asynchr.patch

[patch] 0001-Implement-image-capture-both-synchronous-and-asynchr.patch

0001-Implement-image-capture-both-synchronous-and-asynchr.patch (text/plain), 16.13 KB, created by Vasily Khoruzhick on 2013-03-19 13:04:57 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Vasily Khoruzhick

Created: 2013-03-19 13:04:57 UTC

Size: 16.13 KB

patch

obsolete

>From 4a2b6df33115c2a59e75b1e853b69fb63a194343 Mon Sep 17 00:00:00 2001
>From: Vasily Khoruzhick <anarsoul@gmail.com>
>Date: Fri, 8 Feb 2013 14:38:13 +0300
>Subject: [PATCH 01/10] Implement image capture (both synchronous and
> asynchronous variants)
>
>fp_dev_img_capture() is not implemented and returns -ENOTSUPP for all devices
>since migration to asynchronous model. This commit implement missing functionality
>---
> libfprint/async.c       | 98 +++++++++++++++++++++++++++++++++++++++++++++++++
> libfprint/core.c        | 34 +----------------
> libfprint/fp_internal.h | 20 ++++++++--
> libfprint/fprint.h      | 18 +++++++++
> libfprint/imgdev.c      | 59 +++++++++++++++++++++++------
> libfprint/sync.c        | 97 ++++++++++++++++++++++++++++++++++++++++++++++++
> 6 files changed, 278 insertions(+), 48 deletions(-)
>
>diff --git a/libfprint/async.c b/libfprint/async.c
>index 67e3481..128b7e9 100644
>--- a/libfprint/async.c
>+++ b/libfprint/async.c
>@@ -412,3 +412,101 @@ void fpi_drvcb_identify_stopped(struct fp_dev *dev)
> 		dev->identify_stop_cb(dev, dev->identify_stop_cb_data);
> }
> 
>+API_EXPORTED int fp_async_capture_start(struct fp_dev *dev, int unconditional,
>+	fp_capture_cb callback, void *user_data)
>+{
>+	struct fp_driver *drv = dev->drv;
>+	int r;
>+
>+	fp_dbg("");
>+	if (!drv->capture_start)
>+		return -ENOTSUP;
>+
>+	dev->state = DEV_STATE_CAPTURE_STARTING;
>+	dev->capture_cb = callback;
>+	dev->capture_cb_data = user_data;
>+	dev->unconditional_capture = unconditional;
>+
>+	r = drv->capture_start(dev);
>+	if (r < 0) {
>+		dev->capture_cb = NULL;
>+		dev->state = DEV_STATE_ERROR;
>+		fp_err("failed to start verification, error %d", r);
>+	}
>+	return r;
>+}
>+
>+/* Drivers call this when capture has started */
>+void fpi_drvcb_capture_started(struct fp_dev *dev, int status)
>+{
>+	fp_dbg("");
>+	BUG_ON(dev->state != DEV_STATE_CAPTURE_STARTING);
>+	if (status) {
>+		if (status > 0) {
>+			status = -status;
>+			fp_dbg("adjusted to %d", status);
>+		}
>+		dev->state = DEV_STATE_ERROR;
>+		if (dev->capture_cb)
>+			dev->capture_cb(dev, status, NULL, dev->capture_cb_data);
>+	} else {
>+		dev->state = DEV_STATE_CAPTURING;
>+	}
>+}
>+
>+/* Drivers call this to report a capture result (which might mark completion) */
>+void fpi_drvcb_report_capture_result(struct fp_dev *dev, int result,
>+	struct fp_img *img)
>+{
>+	fp_dbg("result %d", result);
>+	BUG_ON(dev->state != DEV_STATE_CAPTURING);
>+	if (result < 0 || result == FP_CAPTURE_COMPLETE)
>+		dev->state = DEV_STATE_CAPTURE_DONE;
>+
>+	if (dev->capture_cb)
>+		dev->capture_cb(dev, result, img, dev->capture_cb_data);
>+	else
>+		fp_dbg("ignoring capture result as no callback is subscribed");
>+}
>+
>+/* Drivers call this when capture has stopped */
>+void fpi_drvcb_capture_stopped(struct fp_dev *dev)
>+{
>+	fp_dbg("");
>+	BUG_ON(dev->state != DEV_STATE_CAPTURE_STOPPING);
>+	dev->state = DEV_STATE_INITIALIZED;
>+	if (dev->capture_stop_cb)
>+		dev->capture_stop_cb(dev, dev->capture_stop_cb_data);
>+}
>+
>+API_EXPORTED int fp_async_capture_stop(struct fp_dev *dev,
>+	fp_capture_stop_cb callback, void *user_data)
>+{
>+	struct fp_driver *drv = dev->drv;
>+	int r;
>+
>+	fp_dbg("");
>+	BUG_ON(dev->state != DEV_STATE_ERROR
>+		&& dev->state != DEV_STATE_CAPTURING
>+		&& dev->state != DEV_STATE_CAPTURE_DONE);
>+
>+	dev->capture_cb = NULL;
>+	dev->capture_stop_cb = callback;
>+	dev->capture_stop_cb_data = user_data;
>+	dev->state = DEV_STATE_CAPTURE_STOPPING;
>+
>+	if (!drv->capture_start)
>+		return -ENOTSUP;
>+	if (!drv->capture_stop) {
>+		dev->state = DEV_STATE_INITIALIZED;
>+		fpi_drvcb_capture_stopped(dev);
>+		return 0;
>+	}
>+
>+	r = drv->capture_stop(dev);
>+	if (r < 0) {
>+		fp_err("failed to stop verification");
>+		dev->capture_stop_cb = NULL;
>+	}
>+	return r;
>+}
>diff --git a/libfprint/core.c b/libfprint/core.c
>index 5315fdc..238225d 100644
>--- a/libfprint/core.c
>+++ b/libfprint/core.c
>@@ -801,7 +801,7 @@ static struct fp_img_dev *dev_to_img_dev(struct fp_dev *dev)
>  */
> API_EXPORTED int fp_dev_supports_imaging(struct fp_dev *dev)
> {
>-	return dev->drv->type == DRIVER_IMAGING;
>+	return dev->drv->capture_start != NULL;
> }
> 
> /** \ingroup dev
>@@ -817,38 +817,6 @@ API_EXPORTED int fp_dev_supports_identification(struct fp_dev *dev)
> }
> 
> /** \ingroup dev
>- * Captures an \ref img "image" from a device. The returned image is the raw
>- * image provided by the device, you may wish to \ref img_std "standardize" it.
>- *
>- * If set, the <tt>unconditional</tt> flag indicates that the device should
>- * capture an image unconditionally, regardless of whether a finger is there
>- * or not. If unset, this function will block until a finger is detected on
>- * the sensor.
>- *
>- * \param dev the device
>- * \param unconditional whether to unconditionally capture an image, or to only capture when a finger is detected
>- * \param image a location to return the captured image. Must be freed with
>- * fp_img_free() after use.
>- * \return 0 on success, non-zero on error. -ENOTSUP indicates that either the
>- * unconditional flag was set but the device does not support this, or that the
>- * device does not support imaging.
>- * \sa fp_dev_supports_imaging()
>- */
>-API_EXPORTED int fp_dev_img_capture(struct fp_dev *dev, int unconditional,
>-	struct fp_img **image)
>-{
>-	struct fp_img_dev *imgdev = dev_to_img_dev(dev);
>-	if (!imgdev) {
>-		fp_dbg("image capture on non-imaging device");
>-		return -ENOTSUP;
>-	}
>-
>-	//return fpi_imgdev_capture(imgdev, unconditional, image);
>-	/* FIXME reimplement async */
>-	return -ENOTSUP;
>-}
>-
>-/** \ingroup dev
>  * Gets the expected width of images that will be captured from the device.
>  * This function will return -1 for devices that are not
>  * \ref imaging "imaging devices". If the width of images from this device
>diff --git a/libfprint/fp_internal.h b/libfprint/fp_internal.h
>index 04d304f..1468a91 100644
>--- a/libfprint/fp_internal.h
>+++ b/libfprint/fp_internal.h
>@@ -91,6 +91,10 @@ enum fp_dev_state {
> 	DEV_STATE_IDENTIFYING,
> 	DEV_STATE_IDENTIFY_DONE,
> 	DEV_STATE_IDENTIFY_STOPPING,
>+	DEV_STATE_CAPTURE_STARTING,
>+	DEV_STATE_CAPTURING,
>+	DEV_STATE_CAPTURE_DONE,
>+	DEV_STATE_CAPTURE_STOPPING,
> };
> 
> struct fp_driver **fprint_get_drivers (void);
>@@ -108,8 +112,8 @@ struct fp_dev {
> 
> 	/* drivers should not mess with any of the below */
> 	enum fp_dev_state state;
>-
> 	int __enroll_stage;
>+	int unconditional_capture;
> 
> 	/* async I/O callbacks and data */
> 	/* FIXME: convert this to generic state operational data mechanism? */
>@@ -129,6 +133,10 @@ struct fp_dev {
> 	void *identify_cb_data;
> 	fp_identify_stop_cb identify_stop_cb;
> 	void *identify_stop_cb_data;
>+	fp_capture_cb capture_cb;
>+	void *capture_cb_data;
>+	fp_capture_stop_cb capture_stop_cb;
>+	void *capture_stop_cb_data;
> 
> 	/* FIXME: better place to put this? */
> 	struct fp_print_data **identify_gallery;
>@@ -146,6 +154,7 @@ enum fp_imgdev_action {
> 	IMG_ACTION_ENROLL,
> 	IMG_ACTION_VERIFY,
> 	IMG_ACTION_IDENTIFY,
>+	IMG_ACTION_CAPTURE,
> };
> 
> enum fp_imgdev_enroll_state {
>@@ -179,8 +188,6 @@ struct fp_img_dev {
> 	void *priv;
> };
> 
>-int fpi_imgdev_capture(struct fp_img_dev *imgdev, int unconditional,
>-	struct fp_img **image);
> int fpi_imgdev_get_img_width(struct fp_img_dev *imgdev);
> int fpi_imgdev_get_img_height(struct fp_img_dev *imgdev);
> 
>@@ -215,6 +222,8 @@ struct fp_driver {
> 	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);
>+	int (*capture_start)(struct fp_dev *dev);
>+	int (*capture_stop)(struct fp_dev *dev);
> };
> 
> enum fp_print_data_type fpi_driver_get_data_type(struct fp_driver *drv);
>@@ -436,6 +445,11 @@ 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);
> 
>+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);
>+
> /* for image drivers */
> void fpi_imgdev_open_complete(struct fp_img_dev *imgdev, int status);
> void fpi_imgdev_close_complete(struct fp_img_dev *imgdev);
>diff --git a/libfprint/fprint.h b/libfprint/fprint.h
>index 99fa1e1..af1d686 100644
>--- a/libfprint/fprint.h
>+++ b/libfprint/fprint.h
>@@ -107,6 +107,17 @@ uint32_t fp_dev_get_devtype(struct fp_dev *dev);
> int fp_dev_supports_print_data(struct fp_dev *dev, struct fp_print_data *data);
> int fp_dev_supports_dscv_print(struct fp_dev *dev, struct fp_dscv_print *print);
> 
>+/** \ingroup dev
>+ * Image capture result codes returned from fp_dev_img_capture().
>+ */
>+enum fp_capture_result {
>+	/** Capture completed successfully, the capture data has been
>+	 * returned to the caller. */
>+	FP_CAPTURE_COMPLETE = 0,
>+	/** Capture failed for some reason */
>+	FP_CAPTURE_FAIL,
>+};
>+
> int fp_dev_supports_imaging(struct fp_dev *dev);
> int fp_dev_img_capture(struct fp_dev *dev, int unconditional,
> 	struct fp_img **image);
>@@ -340,6 +351,13 @@ typedef void (*fp_identify_stop_cb)(struct fp_dev *dev, void *user_data);
> int fp_async_identify_stop(struct fp_dev *dev, fp_identify_stop_cb callback,
> 	void *user_data);
> 
>+typedef void (*fp_capture_cb)(struct fp_dev *dev, int result,
>+	struct fp_img *img, void *user_data);
>+int fp_async_capture_start(struct fp_dev *dev, int unconditional, fp_capture_cb callback, void *user_data);
>+
>+typedef void (*fp_capture_stop_cb)(struct fp_dev *dev, void *user_data);
>+int fp_async_capture_stop(struct fp_dev *dev, fp_capture_stop_cb callback, void *user_data);
>+
> #ifdef __cplusplus
> }
> #endif
>diff --git a/libfprint/imgdev.c b/libfprint/imgdev.c
>index 1ed3f6d..f83ea11 100644
>--- a/libfprint/imgdev.c
>+++ b/libfprint/imgdev.c
>@@ -163,6 +163,9 @@ void fpi_imgdev_report_finger_status(struct fp_img_dev *imgdev,
> 			imgdev->identify_match_offset, img);
> 		fp_print_data_free(data);
> 		break;
>+	case IMG_ACTION_CAPTURE:
>+		fpi_drvcb_report_capture_result(imgdev->dev, r, img);
>+		break;
> 	default:
> 		fp_err("unhandled action %d", imgdev->action);
> 		break;
>@@ -231,18 +234,20 @@ void fpi_imgdev_image_captured(struct fp_img_dev *imgdev, struct fp_img *img)
> 
> 	fp_img_standardize(img);
> 	imgdev->acquire_img = img;
>-	r = fpi_img_to_print_data(imgdev, img, &print);
>-	if (r < 0) {
>-		fp_dbg("image to print data conversion error: %d", r);
>-		imgdev->action_result = FP_ENROLL_RETRY;
>-		goto next_state;
>-	} else if (img->minutiae->num < MIN_ACCEPTABLE_MINUTIAE) {
>-		fp_dbg("not enough minutiae, %d/%d", img->minutiae->num,
>-			MIN_ACCEPTABLE_MINUTIAE);
>-		fp_print_data_free(print);
>-		/* depends on FP_ENROLL_RETRY == FP_VERIFY_RETRY */
>-		imgdev->action_result = FP_ENROLL_RETRY;
>-		goto next_state;
>+	if (imgdev->action != IMG_ACTION_CAPTURE) {
>+		r = fpi_img_to_print_data(imgdev, img, &print);
>+		if (r < 0) {
>+			fp_dbg("image to print data conversion error: %d", r);
>+			imgdev->action_result = FP_ENROLL_RETRY;
>+			goto next_state;
>+		} else if (img->minutiae->num < MIN_ACCEPTABLE_MINUTIAE) {
>+			fp_dbg("not enough minutiae, %d/%d", img->minutiae->num,
>+				MIN_ACCEPTABLE_MINUTIAE);
>+			fp_print_data_free(print);
>+			/* depends on FP_ENROLL_RETRY == FP_VERIFY_RETRY */
>+			imgdev->action_result = FP_ENROLL_RETRY;
>+			goto next_state;
>+		}
> 	}
> 
> 	imgdev->acquire_data = print;
>@@ -256,6 +261,9 @@ void fpi_imgdev_image_captured(struct fp_img_dev *imgdev, struct fp_img *img)
> 	case IMG_ACTION_IDENTIFY:
> 		identify_process_img(imgdev);
> 		break;
>+	case IMG_ACTION_CAPTURE:
>+		imgdev->action_result = FP_CAPTURE_COMPLETE;
>+		break;
> 	default:
> 		BUG();
> 		break;
>@@ -280,6 +288,9 @@ void fpi_imgdev_session_error(struct fp_img_dev *imgdev, int error)
> 	case IMG_ACTION_IDENTIFY:
> 		fpi_drvcb_report_identify_result(imgdev->dev, error, 0, NULL);
> 		break;
>+	case IMG_ACTION_CAPTURE:
>+		fpi_drvcb_report_capture_result(imgdev->dev, error, NULL);
>+		break;
> 	default:
> 		fp_err("unhandled action %d", imgdev->action);
> 		break;
>@@ -300,6 +311,9 @@ void fpi_imgdev_activate_complete(struct fp_img_dev *imgdev, int status)
> 	case IMG_ACTION_IDENTIFY:
> 		fpi_drvcb_identify_started(imgdev->dev, status);
> 		break;
>+	case IMG_ACTION_CAPTURE:
>+		fpi_drvcb_capture_started(imgdev->dev, status);
>+		break;
> 	default:
> 		fp_err("unhandled action %d", imgdev->action);
> 		return;
>@@ -325,6 +339,9 @@ void fpi_imgdev_deactivate_complete(struct fp_img_dev *imgdev)
> 	case IMG_ACTION_IDENTIFY:
> 		fpi_drvcb_identify_stopped(imgdev->dev);
> 		break;
>+	case IMG_ACTION_CAPTURE:
>+		fpi_drvcb_capture_stopped(imgdev->dev);
>+		break;
> 	default:
> 		fp_err("unhandled action %d", imgdev->action);
> 		break;
>@@ -421,6 +438,14 @@ static int img_dev_identify_start(struct fp_dev *dev)
> 	return generic_acquire_start(dev, IMG_ACTION_IDENTIFY);
> }
> 
>+static int img_dev_capture_start(struct fp_dev *dev)
>+{
>+	/* Unconditional capture is not supported yet */
>+	if (dev->unconditional_capture)
>+		return -ENOTSUP;
>+	return generic_acquire_start(dev, IMG_ACTION_CAPTURE);
>+}
>+
> static int img_dev_enroll_stop(struct fp_dev *dev)
> {
> 	struct fp_img_dev *imgdev = dev->priv;
>@@ -446,6 +471,14 @@ static int img_dev_identify_stop(struct fp_dev *dev, gboolean iterating)
> 	return 0;
> }
> 
>+static int img_dev_capture_stop(struct fp_dev *dev)
>+{
>+	struct fp_img_dev *imgdev = dev->priv;
>+	BUG_ON(imgdev->action != IMG_ACTION_CAPTURE);
>+	generic_acquire_stop(imgdev);
>+	return 0;
>+}
>+
> void fpi_img_driver_setup(struct fp_img_driver *idriver)
> {
> 	idriver->driver.type = DRIVER_IMAGING;
>@@ -457,5 +490,7 @@ void fpi_img_driver_setup(struct fp_img_driver *idriver)
> 	idriver->driver.verify_stop = img_dev_verify_stop;
> 	idriver->driver.identify_start = img_dev_identify_start;
> 	idriver->driver.identify_stop = img_dev_identify_stop;
>+	idriver->driver.capture_start = img_dev_capture_start;
>+	idriver->driver.capture_stop = img_dev_capture_stop;
> }
> 
>diff --git a/libfprint/sync.c b/libfprint/sync.c
>index ca2f302..b3b2898 100644
>--- a/libfprint/sync.c
>+++ b/libfprint/sync.c
>@@ -512,3 +512,100 @@ err:
> 	return r;
> }
> 
>+struct sync_capture_data {
>+	gboolean populated;
>+	int result;
>+	struct fp_img *img;
>+};
>+
>+static void sync_capture_cb(struct fp_dev *dev, int result, struct fp_img *img,
>+	void *user_data)
>+{
>+	struct sync_capture_data *vdata = user_data;
>+	vdata->result = result;
>+	vdata->img = img;
>+	vdata->populated = TRUE;
>+}
>+
>+static void capture_stop_cb(struct fp_dev *dev, void *user_data)
>+{
>+	gboolean *stopped = user_data;
>+	fp_dbg("");
>+	*stopped = TRUE;
>+}
>+/** \ingroup dev
>+ * Captures an \ref img "image" from a device. The returned image is the raw
>+ * image provided by the device, you may wish to \ref img_std "standardize" it.
>+ *
>+ * If set, the <tt>unconditional</tt> flag indicates that the device should
>+ * capture an image unconditionally, regardless of whether a finger is there
>+ * or not. If unset, this function will block until a finger is detected on
>+ * the sensor.
>+ *
>+ * \param dev the device
>+ * \param unconditional whether to unconditionally capture an image, or to only capture when a finger is detected
>+ * \param img a location to return the captured image. Must be freed with
>+ * fp_img_free() after use.
>+ * \return 0 on success, non-zero on error. -ENOTSUP indicates that either the
>+ * unconditional flag was set but the device does not support this, or that the
>+ * device does not support imaging.
>+ * \sa fp_dev_supports_imaging()
>+ */
>+API_EXPORTED int fp_dev_img_capture(struct fp_dev *dev, int unconditional,
>+	struct fp_img **img)
>+{
>+	struct sync_capture_data *vdata;
>+	gboolean stopped = FALSE;
>+	int r;
>+
>+	if (!dev->drv->capture_start) {
>+		fp_dbg("image capture is not supported on %s device", dev->drv->name);
>+		return -ENOTSUP;
>+	}
>+
>+	fp_dbg("to be handled by %s", dev->drv->name);
>+	vdata = g_malloc0(sizeof(struct sync_capture_data));
>+	r = fp_async_capture_start(dev, unconditional, sync_capture_cb, vdata);
>+	if (r < 0) {
>+		fp_dbg("capture_start error %d", r);
>+		g_free(vdata);
>+		return r;
>+	}
>+
>+	while (!vdata->populated) {
>+		r = fp_handle_events();
>+		if (r < 0) {
>+			g_free(vdata);
>+			goto err;
>+		}
>+	}
>+
>+	if (img)
>+		*img = vdata->img;
>+	else
>+		fp_img_free(vdata->img);
>+
>+	r = vdata->result;
>+	g_free(vdata);
>+	switch (r) {
>+	case FP_CAPTURE_COMPLETE:
>+		fp_dbg("result: complete");
>+		break;
>+	case FP_CAPTURE_FAIL:
>+		fp_dbg("result: fail");
>+		break;
>+	default:
>+		fp_err("unrecognised return code %d", r);
>+		r = -EINVAL;
>+	}
>+
>+err:
>+	fp_dbg("ending capture");
>+	if (fp_async_capture_stop(dev, capture_stop_cb, &stopped) == 0)
>+		while (!stopped)
>+			if (fp_handle_events() < 0)
>+				break;
>+
>+	return r;
>+}
>+
>-- 
>1.8.2
>

Actions: View | Splinter Review

Attachments on bug 60445: 76751

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.