summaryrefslogtreecommitdiff
path: root/src/scanner.c
diff options
context:
space:
mode:
authorAlessio Treglia <quadrispro@ubuntu.com>2010-04-09 13:10:42 +0200
committerAlessio Treglia <quadrispro@ubuntu.com>2010-04-09 13:10:42 +0200
commitcf7d885d901b0abdccaad5cc3305a080744eaf5b (patch)
treebf56ba367a8a872dc562fcf8cce9af6aebae67af /src/scanner.c
Imported Upstream version 0.9.10upstream/0.9.10
Diffstat (limited to 'src/scanner.c')
-rw-r--r--src/scanner.c1630
1 files changed, 1630 insertions, 0 deletions
diff --git a/src/scanner.c b/src/scanner.c
new file mode 100644
index 0000000..daf1b15
--- /dev/null
+++ b/src/scanner.c
@@ -0,0 +1,1630 @@
+/*
+ * Copyright (C) 2009 Canonical Ltd.
+ * Author: Robert Ancell <robert.ancell@canonical.com>
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
+ * license.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <sane/sane.h>
+#include <sane/saneopts.h>
+#include <glib/gi18n.h>
+
+#include "scanner.h"
+
+/* TODO: Could indicate the start of the next page immediately after the last page is received (i.e. before the sane_cancel()) */
+
+enum {
+ UPDATE_DEVICES,
+ AUTHORIZE,
+ EXPECT_PAGE,
+ GOT_PAGE_INFO,
+ GOT_LINE,
+ SCAN_FAILED,
+ PAGE_DONE,
+ DOCUMENT_DONE,
+ SCANNING_CHANGED,
+ LAST_SIGNAL
+};
+static guint signals[LAST_SIGNAL] = { 0, };
+
+typedef struct
+{
+ Scanner *instance;
+ guint sig;
+ gpointer data;
+} SignalInfo;
+
+typedef struct
+{
+ gchar *device;
+ gdouble dpi;
+ ScanMode scan_mode;
+ gint depth;
+ gboolean type;
+ gint page_width, page_height;
+} ScanJob;
+
+typedef struct
+{
+ enum
+ {
+ REQUEST_CANCEL,
+ REQUEST_REDETECT,
+ REQUEST_START_SCAN,
+ REQUEST_QUIT
+ } type;
+ ScanJob *job;
+} ScanRequest;
+
+typedef struct
+{
+ gchar *username, *password;
+} Credentials;
+
+typedef enum
+{
+ STATE_IDLE = 0,
+ STATE_REDETECT,
+ STATE_OPEN,
+ STATE_GET_OPTION,
+ STATE_START,
+ STATE_GET_PARAMETERS,
+ STATE_READ
+} ScanState;
+
+struct ScannerPrivate
+{
+ GAsyncQueue *scan_queue, *authorize_queue;
+ GThread *thread;
+
+ gchar *default_device;
+
+ ScanState state;
+ gboolean redetect;
+
+ GList *job_queue;
+
+ /* Handle to SANE device */
+ SANE_Handle handle;
+ gchar *current_device;
+
+ SANE_Parameters parameters;
+
+ /* Last option read */
+ SANE_Int option_index;
+
+ /* Buffer for received line */
+ SANE_Byte *buffer;
+ SANE_Int buffer_size, n_used;
+
+ SANE_Int bytes_remaining, line_count, pass_number, page_number, notified_page;
+
+ gboolean scanning;
+};
+
+G_DEFINE_TYPE (Scanner, scanner, G_TYPE_OBJECT);
+
+
+/* Table of scanner objects for each thread (required for authorization callback) */
+static GHashTable *scanners;
+
+
+static gboolean
+send_signal (SignalInfo *info)
+{
+ g_signal_emit (info->instance, signals[info->sig], 0, info->data);
+
+ switch (info->sig) {
+ case UPDATE_DEVICES:
+ {
+ GList *iter, *devices = info->data;
+ for (iter = devices; iter; iter = iter->next) {
+ ScanDevice *device = iter->data;
+ g_free (device->name);
+ g_free (device->label);
+ g_free (device);
+ }
+ g_list_free (devices);
+ }
+ break;
+ case AUTHORIZE:
+ {
+ gchar *resource = info->data;
+ g_free (resource);
+ }
+ break;
+ case GOT_PAGE_INFO:
+ {
+ ScanPageInfo *page_info = info->data;
+ g_free (page_info);
+ }
+ break;
+ case GOT_LINE:
+ {
+ ScanLine *line = info->data;
+ g_free(line->data);
+ g_free(line);
+ }
+ break;
+ case SCAN_FAILED:
+ {
+ GError *error = info->data;
+ g_error_free (error);
+ }
+ break;
+ default:
+ case EXPECT_PAGE:
+ case PAGE_DONE:
+ case DOCUMENT_DONE:
+ case LAST_SIGNAL:
+ g_assert (info->data == NULL);
+ break;
+ }
+ g_free (info);
+
+ return FALSE;
+}
+
+
+/* Emit signals in main loop */
+static void
+emit_signal (Scanner *scanner, guint sig, gpointer data)
+{
+ SignalInfo *info;
+
+ info = g_malloc(sizeof(SignalInfo));
+ info->instance = scanner;
+ info->sig = sig;
+ info->data = data;
+ g_idle_add ((GSourceFunc) send_signal, info);
+}
+
+
+static void
+set_scanning (Scanner *scanner, gboolean is_scanning)
+{
+ if ((scanner->priv->scanning && !is_scanning) || (!scanner->priv->scanning && is_scanning)) {
+ scanner->priv->scanning = is_scanning;
+ emit_signal (scanner, SCANNING_CHANGED, NULL);
+ }
+}
+
+
+static gint
+get_device_weight (const gchar *device)
+{
+ /* NOTE: This is using trends in the naming of SANE devices, SANE should be able to provide this information better */
+
+ /* Use webcams as a last resort */
+ if (g_str_has_prefix (device, "vfl:"))
+ return 2;
+
+ /* Use locally connected devices first */
+ if (strstr (device, "usb"))
+ return 0;
+
+ return 1;
+}
+
+
+static gint
+compare_devices (ScanDevice *device1, ScanDevice *device2)
+{
+ gint weight1, weight2;
+
+ /* TODO: Should do some fuzzy matching on the last selected device and set that to the default */
+
+ weight1 = get_device_weight (device1->name);
+ weight2 = get_device_weight (device2->name);
+ if (weight1 != weight2)
+ return weight1 - weight2;
+
+ return strcmp (device1->label, device2->label);
+}
+
+
+static const char *
+get_status_string (SANE_Status status)
+{
+ struct {
+ SANE_Status status;
+ const char *name;
+ } status_names[] = {
+ { SANE_STATUS_GOOD, "SANE_STATUS_GOOD"},
+ { SANE_STATUS_UNSUPPORTED, "SANE_STATUS_UNSUPPORTED"},
+ { SANE_STATUS_CANCELLED, "SANE_STATUS_CANCELLED"},
+ { SANE_STATUS_DEVICE_BUSY, "SANE_STATUS_DEVICE_BUSY"},
+ { SANE_STATUS_INVAL, "SANE_STATUS_INVAL"},
+ { SANE_STATUS_EOF, "SANE_STATUS_EOF"},
+ { SANE_STATUS_JAMMED, "SANE_STATUS_JAMMED"},
+ { SANE_STATUS_NO_DOCS, "SANE_STATUS_NO_DOCS"},
+ { SANE_STATUS_COVER_OPEN, "SANE_STATUS_COVER_OPEN"},
+ { SANE_STATUS_IO_ERROR, "SANE_STATUS_IO_ERROR"},
+ { SANE_STATUS_NO_MEM, "SANE_STATUS_NO_MEM"},
+ { SANE_STATUS_ACCESS_DENIED, "SANE_STATUS_ACCESS_DENIED"},
+ { -1, NULL}
+ };
+ static char *unknown_string = NULL;
+ int i;
+
+ for (i = 0; status_names[i].name != NULL && status_names[i].status != status; i++);
+
+ if (status_names[i].name == NULL) {
+ g_free (unknown_string);
+ unknown_string = g_strdup_printf ("SANE_STATUS(%d)", status);
+ return unknown_string; /* Note result is undefined on second call to this function */
+ }
+
+ return status_names[i].name;
+}
+
+
+static const char *
+get_action_string (SANE_Action action)
+{
+ struct {
+ SANE_Action action;
+ const char *name;
+ } action_names[] = {
+ { SANE_ACTION_GET_VALUE, "SANE_ACTION_GET_VALUE" },
+ { SANE_ACTION_SET_VALUE, "SANE_ACTION_SET_VALUE" },
+ { SANE_ACTION_SET_AUTO, "SANE_ACTION_SET_AUTO" },
+ { -1, NULL}
+ };
+ static char *unknown_string = NULL;
+ int i;
+
+ for (i = 0; action_names[i].name != NULL && action_names[i].action != action; i++);
+
+ if (action_names[i].name == NULL) {
+ g_free (unknown_string);
+ unknown_string = g_strdup_printf ("SANE_ACTION(%d)", action);
+ return unknown_string; /* Note result is undefined on second call to this function */
+ }
+
+ return action_names[i].name;
+}
+
+
+static const char *
+get_frame_string (SANE_Frame frame)
+{
+ struct {
+ SANE_Frame frame;
+ const char *name;
+ } frame_names[] = {
+ { SANE_FRAME_GRAY, "SANE_FRAME_GRAY" },
+ { SANE_FRAME_RGB, "SANE_FRAME_RGB" },
+ { SANE_FRAME_RED, "SANE_FRAME_RED" },
+ { SANE_FRAME_GREEN, "SANE_FRAME_GREEN" },
+ { SANE_FRAME_BLUE, "SANE_FRAME_BLUE" },
+ { -1, NULL}
+ };
+ static char *unknown_string = NULL;
+ int i;
+
+ for (i = 0; frame_names[i].name != NULL && frame_names[i].frame != frame; i++);
+
+ if (frame_names[i].name == NULL) {
+ g_free (unknown_string);
+ unknown_string = g_strdup_printf ("SANE_FRAME(%d)", frame);
+ return unknown_string; /* Note result is undefined on second call to this function */
+ }
+
+ return frame_names[i].name;
+}
+
+
+static void
+do_redetect (Scanner *scanner)
+{
+ const SANE_Device **device_list, **device_iter;
+ SANE_Status status;
+ GList *devices = NULL;
+
+ status = sane_get_devices (&device_list, SANE_FALSE);
+ g_debug ("sane_get_devices () -> %s", get_status_string (status));
+ if (status != SANE_STATUS_GOOD) {
+ g_warning ("Unable to get SANE devices: %s", sane_strstatus(status));
+ scanner->priv->state = STATE_IDLE;
+ return;
+ }
+
+ for (device_iter = device_list; *device_iter; device_iter++) {
+ const SANE_Device *device = *device_iter;
+ ScanDevice *scan_device;
+ gchar *c, *label;
+
+ g_debug ("Device: name=\"%s\" vendor=\"%s\" model=\"%s\" type=\"%s\"",
+ device->name, device->vendor, device->model, device->type);
+
+ scan_device = g_malloc0 (sizeof (ScanDevice));
+
+ scan_device->name = g_strdup (device->name);
+
+ /* Abbreviate HP as it is a long string and does not match what is on the physical scanner */
+ if (strcmp (device->vendor, "Hewlett-Packard") == 0)
+ label = g_strdup_printf ("HP %s", device->model);
+ else
+ label = g_strdup_printf ("%s %s", device->vendor, device->model);
+
+ /* Replace underscored in name */
+ for (c = label; *c; c++)
+ if (*c == '_')
+ *c = ' ';
+
+ scan_device->label = label;
+
+ devices = g_list_append (devices, scan_device);
+ }
+
+ /* Sort devices by priority */
+ devices = g_list_sort (devices, (GCompareFunc) compare_devices);
+
+ scanner->priv->redetect = FALSE;
+ scanner->priv->state = STATE_IDLE;
+
+ g_free (scanner->priv->default_device);
+ if (devices) {
+ ScanDevice *device = g_list_nth_data (devices, 0);
+ scanner->priv->default_device = g_strdup (device->name);
+ }
+ else
+ scanner->priv->default_device = NULL;
+
+ emit_signal (scanner, UPDATE_DEVICES, devices);
+}
+
+
+static gboolean
+control_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int index, SANE_Action action, void *value)
+{
+ SANE_Status status;
+ gchar *old_value;
+
+ switch (option->type) {
+ case SANE_TYPE_BOOL:
+ old_value = g_strdup_printf (*((SANE_Bool *) value) ? "SANE_TRUE" : "SANE_FALSE");
+ break;
+ case SANE_TYPE_INT:
+ old_value = g_strdup_printf ("%d", *((SANE_Int *) value));
+ break;
+ case SANE_TYPE_FIXED:
+ old_value = g_strdup_printf ("%f", SANE_UNFIX (*((SANE_Fixed *) value)));
+ break;
+ case SANE_TYPE_STRING:
+ old_value = g_strdup_printf ("\"%s\"", (char *) value);
+ break;
+ default:
+ old_value = g_strdup ("?");
+ break;
+ }
+
+ status = sane_control_option (handle, index, action, value, NULL);
+ switch (option->type) {
+ case SANE_TYPE_BOOL:
+ g_debug ("sane_control_option (%d, %s, %s) -> (%s, %s)",
+ index, get_action_string (action),
+ *((SANE_Bool *) value) ? "SANE_TRUE" : "SANE_FALSE",
+ get_status_string (status),
+ old_value);
+ break;
+ case SANE_TYPE_INT:
+ g_debug ("sane_control_option (%d, %s, %d) -> (%s, %s)",
+ index, get_action_string (action),
+ *((SANE_Int *) value),
+ get_status_string (status),
+ old_value);
+ break;
+ case SANE_TYPE_FIXED:
+ g_debug ("sane_control_option (%d, %s, %f) -> (%s, %s)",
+ index, get_action_string (action),
+ SANE_UNFIX (*((SANE_Fixed *) value)),
+ get_status_string (status),
+ old_value);
+ break;
+ case SANE_TYPE_STRING:
+ g_debug ("sane_control_option (%d, %s, \"%s\") -> (%s, %s)",
+ index, get_action_string (action),
+ (char *) value,
+ get_status_string (status),
+ old_value);
+ break;
+ default:
+ break;
+ }
+ g_free (old_value);
+
+ if (status != SANE_STATUS_GOOD)
+ g_warning ("Error setting option %s: %s", option->name, sane_strstatus(status));
+
+ return status == SANE_STATUS_GOOD;
+}
+
+
+static gboolean
+set_default_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index)
+{
+ SANE_Status status;
+
+ status = sane_control_option (handle, option_index, SANE_ACTION_SET_AUTO, NULL, NULL);
+ g_debug ("sane_control_option (%d, SANE_ACTION_SET_AUTO) -> %s",
+ option_index, get_status_string (status));
+ if (status != SANE_STATUS_GOOD)
+ g_warning ("Error setting default option %s: %s", option->name, sane_strstatus(status));
+
+ return status == SANE_STATUS_GOOD;
+}
+
+
+static void
+set_bool_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, SANE_Bool value, SANE_Bool *result)
+{
+ SANE_Bool v = value;
+ g_return_if_fail (option->type == SANE_TYPE_BOOL);
+ control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, &v);
+ if (result)
+ *result = v;
+}
+
+
+static void
+set_int_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, SANE_Int value, SANE_Int *result)
+{
+ SANE_Int v = value;
+
+ g_return_if_fail (option->type == SANE_TYPE_INT);
+
+ if (option->constraint_type == SANE_CONSTRAINT_RANGE) {
+ if (option->constraint.range->quant)
+ v *= option->constraint.range->quant;
+ if (v < option->constraint.range->min)
+ v = option->constraint.range->min;
+ if (v > option->constraint.range->max)
+ v = option->constraint.range->max;
+ }
+ else if (option->constraint_type == SANE_CONSTRAINT_WORD_LIST) {
+ int i;
+ SANE_Int distance = INT_MAX, nearest = 0;
+
+ /* Find nearest value to requested */
+ for (i = 0; i < option->constraint.word_list[0]; i++) {
+ SANE_Int x = option->constraint.word_list[i+1];
+ if (abs (x - v) < distance) {
+ distance = abs (x - v);
+ nearest = x;
+ }
+ }
+ v = nearest;
+ }
+
+ control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, &v);
+ if (result)
+ *result = v;
+}
+
+
+static void
+set_fixed_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, gdouble value, gdouble *result)
+{
+ gdouble v = value;
+ SANE_Fixed v_fixed;
+
+ g_return_if_fail (option->type == SANE_TYPE_FIXED);
+
+ if (option->constraint_type == SANE_CONSTRAINT_RANGE) {
+ double min = SANE_UNFIX (option->constraint.range->min);
+ double max = SANE_UNFIX (option->constraint.range->max);
+
+ if (v < min)
+ v = min;
+ if (v > max)
+ v = max;
+ }
+ else if (option->constraint_type == SANE_CONSTRAINT_WORD_LIST) {
+ int i;
+ double distance = DBL_MAX, nearest = 0.0;
+
+ /* Find nearest value to requested */
+ for (i = 0; i < option->constraint.word_list[0]; i++) {
+ double x = SANE_UNFIX (option->constraint.word_list[i+1]);
+ if (fabs (x - v) < distance) {
+ distance = fabs (x - v);
+ nearest = x;
+ }
+ }
+ v = nearest;
+ }
+
+ v_fixed = SANE_FIX (v);
+ control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, &v_fixed);
+ if (result)
+ *result = SANE_UNFIX (v_fixed);
+}
+
+
+static gboolean
+set_string_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, const char *value, char **result)
+{
+ char *string;
+ gsize value_size, size;
+ gboolean error;
+
+ g_return_val_if_fail (option->type == SANE_TYPE_STRING, FALSE);
+
+ value_size = strlen (value) + 1;
+ size = option->size > value_size ? option->size : value_size;
+ string = g_malloc(sizeof(char) * size);
+ strcpy (string, value);
+ error = control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, string);
+ if (result)
+ *result = string;
+ else
+ g_free (string);
+
+ return error;
+}
+
+
+static gboolean
+set_constrained_string_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, const char *values[], char **result)
+{
+ gint i, j;
+
+ g_return_val_if_fail (option->type == SANE_TYPE_STRING, FALSE);
+ g_return_val_if_fail (option->constraint_type == SANE_CONSTRAINT_STRING_LIST, FALSE);
+
+ for (i = 0; values[i] != NULL; i++) {
+ for (j = 0; option->constraint.string_list[j]; j++) {
+ if (strcmp (values[i], option->constraint.string_list[j]) == 0)
+ break;
+ }
+
+ if (option->constraint.string_list[j] != NULL)
+ return set_string_option (handle, option, option_index, values[i], result);
+ }
+
+ return FALSE;
+}
+
+
+static void
+log_option (SANE_Int index, const SANE_Option_Descriptor *option)
+{
+ GString *string;
+ SANE_Word i;
+ SANE_Int cap;
+
+ string = g_string_new ("");
+
+ g_string_append_printf (string, "Option %d:", index);
+
+ if (option->name)
+ g_string_append_printf (string, " name='%s'", option->name);
+
+ if (option->title)
+ g_string_append_printf (string, " title='%s'", option->title);
+
+ switch (option->type) {
+ case SANE_TYPE_BOOL:
+ g_string_append (string, " type=bool");
+ break;
+ case SANE_TYPE_INT:
+ g_string_append (string, " type=int");
+ break;
+ case SANE_TYPE_FIXED:
+ g_string_append (string, " type=fixed");
+ break;
+ case SANE_TYPE_STRING:
+ g_string_append (string, " type=string");
+ break;
+ case SANE_TYPE_BUTTON:
+ g_string_append (string, " type=button");
+ break;
+ case SANE_TYPE_GROUP:
+ g_string_append (string, " type=group");
+ break;
+ default:
+ g_string_append_printf (string, " type=%d", option->type);
+ break;
+ }
+
+ g_string_append_printf (string, " size=%d", option->size);
+
+ switch (option->unit) {
+ case SANE_UNIT_NONE:
+ break;
+ case SANE_UNIT_PIXEL:
+ g_string_append (string, " unit=pixels");
+ break;
+ case SANE_UNIT_BIT:
+ g_string_append (string, " unit=bits");
+ break;
+ case SANE_UNIT_MM:
+ g_string_append (string, " unit=mm");
+ break;
+ case SANE_UNIT_DPI:
+ g_string_append (string, " unit=dpi");
+ break;
+ case SANE_UNIT_PERCENT:
+ g_string_append (string, " unit=percent");
+ break;
+ case SANE_UNIT_MICROSECOND:
+ g_string_append (string, " unit=microseconds");
+ break;
+ default:
+ g_string_append_printf (string, " unit=%d", option->unit);
+ break;
+ }
+
+ switch (option->constraint_type) {
+ case SANE_CONSTRAINT_RANGE:
+ if (option->type == SANE_TYPE_FIXED)
+ g_string_append_printf (string, " min=%f, max=%f, quant=%d",
+ SANE_UNFIX (option->constraint.range->min), SANE_UNFIX (option->constraint.range->max),
+ option->constraint.range->quant);
+ else
+ g_string_append_printf (string, " min=%d, max=%d, quant=%d",
+ option->constraint.range->min, option->constraint.range->max,
+ option->constraint.range->quant);
+ break;
+ case SANE_CONSTRAINT_WORD_LIST:
+ g_string_append (string, " values=[");
+ for (i = 0; i < option->constraint.word_list[0]; i++) {
+ if (i != 0)
+ g_string_append (string, ", ");
+ if (option->type == SANE_TYPE_INT)
+ g_string_append_printf (string, "%d", option->constraint.word_list[i+1]);
+ else
+ g_string_append_printf (string, "%f", SANE_UNFIX (option->constraint.word_list[i+1]));
+ }
+ g_string_append (string, "]");
+ break;
+ case SANE_CONSTRAINT_STRING_LIST:
+ g_string_append (string, " values=[");
+ for (i = 0; option->constraint.string_list[i]; i++) {
+ if (i != 0)
+ g_string_append (string, ", ");
+ g_string_append_printf (string, "\"%s\"", option->constraint.string_list[i]);
+ }
+ g_string_append (string, "]");
+ break;
+ default:
+ break;
+ }
+
+ cap = option->cap;
+ if (cap) {
+ struct {
+ SANE_Int cap;
+ const char *name;
+ } caps[] = {
+ { SANE_CAP_SOFT_SELECT, "soft-select"},
+ { SANE_CAP_HARD_SELECT, "hard-select"},
+ { SANE_CAP_SOFT_DETECT, "soft-detect"},
+ { SANE_CAP_EMULATED, "emulated"},
+ { SANE_CAP_AUTOMATIC, "automatic"},
+ { SANE_CAP_INACTIVE, "inactive"},
+ { SANE_CAP_ADVANCED, "advanced"},
+ { 0, NULL}
+ };
+ int i, n = 0;
+
+ g_string_append (string, " cap=");
+ for (i = 0; caps[i].cap > 0; i++) {
+ if (cap & caps[i].cap) {
+ cap &= ~caps[i].cap;
+ if (n != 0)
+ g_string_append (string, ",");
+ g_string_append (string, caps[i].name);
+ n++;
+ }
+ }
+ /* Unknown capabilities */
+ if (cap) {
+ if (n != 0)
+ g_string_append (string, ",");
+ g_string_append_printf (string, "%x", cap);
+ }
+ }
+
+ g_debug ("%s", string->str);
+ g_string_free (string, TRUE);
+
+ if (option->desc)
+ g_debug (" Description: %s", option->desc);
+}
+
+
+static void
+authorization_cb (SANE_String_Const resource, SANE_Char username[SANE_MAX_USERNAME_LEN], SANE_Char password[SANE_MAX_PASSWORD_LEN])
+{
+ Scanner *scanner;
+ Credentials *credentials;
+
+ scanner = g_hash_table_lookup (scanners, g_thread_self ());
+
+ emit_signal (scanner, AUTHORIZE, g_strdup (resource));
+
+ credentials = g_async_queue_pop (scanner->priv->authorize_queue);
+ strncpy (username, credentials->username, SANE_MAX_USERNAME_LEN);
+ strncpy (password, credentials->password, SANE_MAX_PASSWORD_LEN);
+ g_free (credentials);
+}
+
+
+void
+scanner_authorize (Scanner *scanner, const gchar *username, const gchar *password)
+{
+ Credentials *credentials;
+
+ credentials = g_malloc (sizeof (Credentials));
+ credentials->username = g_strdup (username);
+ credentials->password = g_strdup (password);
+ g_async_queue_push (scanner->priv->authorize_queue, credentials);
+}
+
+
+static void
+close_device (Scanner *scanner)
+{
+ GList *iter;
+
+ if (scanner->priv->handle) {
+ sane_cancel (scanner->priv->handle);
+ g_debug ("sane_cancel ()");
+
+ sane_close (scanner->priv->handle);
+ g_debug ("sane_close ()");
+ scanner->priv->handle = NULL;
+ }
+
+ g_free (scanner->priv->buffer);
+ scanner->priv->buffer = NULL;
+
+ for (iter = scanner->priv->job_queue; iter; iter = iter->next) {
+ ScanJob *job = (ScanJob *) iter->data;
+ g_free (job->device);
+ g_free (job);
+ }
+ g_list_free (scanner->priv->job_queue);
+ scanner->priv->job_queue = NULL;
+
+ set_scanning (scanner, FALSE);
+}
+
+static void
+fail_scan (Scanner *scanner, gint error_code, const gchar *error_string)
+{
+ close_device (scanner);
+ scanner->priv->state = STATE_IDLE;
+ emit_signal (scanner, SCAN_FAILED, g_error_new (SCANNER_TYPE, error_code, "%s", error_string));
+}
+
+
+static gboolean
+handle_requests (Scanner *scanner)
+{
+ gint request_count = 0;
+
+ /* Redetect when idle */
+ if (scanner->priv->state == STATE_IDLE && scanner->priv->redetect)
+ scanner->priv->state = STATE_REDETECT;
+
+ /* Process all requests */
+ while (TRUE) {
+ ScanRequest *request = NULL;
+
+ if ((scanner->priv->state == STATE_IDLE && request_count == 0) ||
+ g_async_queue_length (scanner->priv->scan_queue) > 0)
+ request = g_async_queue_pop (scanner->priv->scan_queue);
+ else
+ return TRUE;
+
+ g_debug ("Processing request");
+ request_count++;
+
+ switch (request->type) {
+ case REQUEST_REDETECT:
+ break;
+
+ case REQUEST_START_SCAN:
+ scanner->priv->job_queue = g_list_append (scanner->priv->job_queue, request->job);
+ break;
+
+ case REQUEST_CANCEL:
+ fail_scan (scanner, SANE_STATUS_CANCELLED, "Scan cancelled - do not report this error");
+ break;
+
+ case REQUEST_QUIT:
+ close_device (scanner);
+ g_free (request);
+ return FALSE;
+ }
+
+ g_free (request);
+ }
+
+ return TRUE;
+}
+
+
+static void
+do_open (Scanner *scanner)
+{
+ SANE_Status status;
+ ScanJob *job;
+
+ job = (ScanJob *) scanner->priv->job_queue->data;
+
+ scanner->priv->line_count = 0;
+ scanner->priv->pass_number = 0;
+ scanner->priv->page_number = 0;
+ scanner->priv->notified_page = -1;
+ scanner->priv->option_index = 0;
+
+ if (!job->device && scanner->priv->default_device)
+ job->device = g_strdup (scanner->priv->default_device);
+
+ if (!job->device) {
+ g_warning ("No scan device available");
+ fail_scan (scanner, status,
+ /* Error displayed when no scanners to scan with */
+ _("No scanners available. Please connect a scanner."));
+ return;
+ }
+
+ /* See if we can use the already open device */
+ if (scanner->priv->handle) {
+ if (strcmp (scanner->priv->current_device, job->device) == 0) {
+ scanner->priv->state = STATE_GET_OPTION;
+ return;
+ }
+
+ sane_close (scanner->priv->handle);
+ g_debug ("sane_close ()");
+ scanner->priv->handle = NULL;
+ }
+
+ g_free (scanner->priv->current_device);
+ scanner->priv->current_device = NULL;
+
+ status = sane_open (job->device, &scanner->priv->handle);
+ g_debug ("sane_open (\"%s\") -> %s", job->device, get_status_string (status));
+
+ if (status != SANE_STATUS_GOOD) {
+ g_warning ("Unable to get open device: %s", sane_strstatus (status));
+ scanner->priv->handle = NULL;
+ fail_scan (scanner, status,
+ /* Error displayed when cannot connect to scanner */
+ _("Unable to connect to scanner"));
+ return;
+ }
+
+ scanner->priv->current_device = g_strdup (job->device);
+ scanner->priv->state = STATE_GET_OPTION;
+}
+
+
+static void
+do_get_option (Scanner *scanner)
+{
+ const SANE_Option_Descriptor *option;
+ SANE_Int option_index;
+ ScanJob *job;
+
+ job = (ScanJob *) scanner->priv->job_queue->data;
+
+ option = sane_get_option_descriptor (scanner->priv->handle, scanner->priv->option_index);
+ g_debug ("sane_get_option_descriptor (%d)", scanner->priv->option_index);
+ option_index = scanner->priv->option_index;
+ scanner->priv->option_index++;
+
+ if (!option) {
+ scanner->priv->state = STATE_START;
+ return;
+ }
+
+ log_option (option_index, option);
+
+ /* Ignore groups */
+ if (option->type == SANE_TYPE_GROUP)
+ return;
+
+ /* Option disabled */
+ if (option->cap & SANE_CAP_INACTIVE)
+ return;
+
+ /* Some options are unnammed (e.g. Option 0) */
+ if (option->name == NULL)
+ return;
+
+ if (strcmp (option->name, SANE_NAME_SCAN_RESOLUTION) == 0) {
+ if (option->type == SANE_TYPE_FIXED) {
+ set_fixed_option (scanner->priv->handle, option, option_index, job->dpi, &job->dpi);
+ }
+ else {
+ SANE_Int dpi;
+ set_int_option (scanner->priv->handle, option, option_index, job->dpi, &dpi);
+ job->dpi = dpi;
+ }
+ }
+ else if (strcmp (option->name, SANE_NAME_SCAN_SOURCE) == 0) {
+ const char *flatbed_sources[] =
+ {
+ "Flatbed",
+ SANE_I18N ("Flatbed"),
+ "FlatBed",
+ "Normal",
+ SANE_I18N ("Normal"),
+ NULL
+ };
+
+ const char *adf_sources[] =
+ {
+ "Automatic Document Feeder",
+ SANE_I18N ("Automatic Document Feeder"),
+ "ADF",
+ "Automatic Document Feeder(left aligned)", /* Seen in the proprietary brother3 driver */
+ "Automatic Document Feeder(centrally aligned)", /* Seen in the proprietary brother3 driver */
+ NULL
+ };
+
+ const char *adf_front_sources[] =
+ {
+ "ADF Front",
+ SANE_I18N ("ADF Front"),
+ NULL
+ };
+
+ const char *adf_back_sources[] =
+ {
+ "ADF Back",
+ SANE_I18N ("ADF Back"),
+ NULL
+ };
+
+ const char *adf_duplex_sources[] =
+ {
+ "ADF Duplex",
+ SANE_I18N ("ADF Duplex"),
+ NULL
+ };
+
+ switch (job->type) {
+ case SCAN_SINGLE:
+ if (!set_default_option (scanner->priv->handle, option, option_index))
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, flatbed_sources, NULL))
+ g_warning ("Unable to set single page source, please file a bug");
+ break;
+ case SCAN_ADF_FRONT:
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_front_sources, NULL))
+ if (!!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_sources, NULL))
+ g_warning ("Unable to set front ADF source, please file a bug");
+ break;
+ case SCAN_ADF_BACK:
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_back_sources, NULL))
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_sources, NULL))
+ g_warning ("Unable to set back ADF source, please file a bug");
+ break;
+ case SCAN_ADF_BOTH:
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_duplex_sources, NULL))
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_sources, NULL))
+ g_warning ("Unable to set duplex ADF source, please file a bug");
+ break;
+ }
+ }
+ else if (strcmp (option->name, SANE_NAME_BIT_DEPTH) == 0) {
+ if (job->depth > 0)
+ set_int_option (scanner->priv->handle, option, option_index, job->depth, NULL);
+ }
+ else if (strcmp (option->name, SANE_NAME_SCAN_MODE) == 0) {
+ /* The names of scan modes often used in drivers, as taken from the sane-backends source */
+ const char *color_scan_modes[] =
+ {
+ SANE_VALUE_SCAN_MODE_COLOR,
+ "Color",
+ "24bit Color", /* Seen in the proprietary brother3 driver */
+ NULL
+ };
+ const char *gray_scan_modes[] =
+ {
+ SANE_VALUE_SCAN_MODE_GRAY,
+ "Gray",
+ "Grayscale",
+ SANE_I18N ("Grayscale"),
+ NULL
+ };
+ const char *lineart_scan_modes[] =
+ {
+ SANE_VALUE_SCAN_MODE_LINEART,
+ "Lineart",
+ "LineArt",
+ SANE_I18N ("LineArt"),
+ "Black & White",
+ SANE_I18N ("Black & White"),
+ "Binary",
+ SANE_I18N ("Binary"),
+ "Thresholded",
+ SANE_VALUE_SCAN_MODE_GRAY,
+ "Gray",
+ "Grayscale",
+ SANE_I18N ("Grayscale"),
+ NULL
+ };
+
+ switch (job->scan_mode) {
+ case SCAN_MODE_COLOR:
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, color_scan_modes, NULL))
+ g_warning ("Unable to set Color mode, please file a bug");
+ break;
+ case SCAN_MODE_GRAY:
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, gray_scan_modes, NULL))
+ g_warning ("Unable to set Gray mode, please file a bug");
+ break;
+ case SCAN_MODE_LINEART:
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, lineart_scan_modes, NULL))
+ g_warning ("Unable to set Lineart mode, please file a bug");
+ break;
+ default:
+ break;
+ }
+ }
+ /* Disable compression, we will compress after scanning */
+ else if (strcmp (option->name, "compression") == 0) {
+ const char *disable_compression_names[] =
+ {
+ SANE_I18N ("None"),
+ SANE_I18N ("none"),
+ "None",
+ "none",
+ NULL
+ };
+
+ if (!set_constrained_string_option (scanner->priv->handle, option, option_index, disable_compression_names, NULL))
+ g_warning ("Unable to disable compression, please file a bug");
+ }
+ /* Always use maximum scan area - some scanners default to using partial areas. This should be patched in sane-backends */
+ else if (strcmp (option->name, SANE_NAME_SCAN_BR_X) == 0 ||
+ strcmp (option->name, SANE_NAME_SCAN_BR_Y) == 0) {
+ switch (option->constraint_type)
+ {
+ case SANE_CONSTRAINT_RANGE:
+ if (option->type == SANE_TYPE_FIXED)
+ set_fixed_option (scanner->priv->handle, option, option_index, SANE_UNFIX (option->constraint.range->max), NULL);
+ else
+ set_int_option (scanner->priv->handle, option, option_index, option->constraint.range->max, NULL);
+ break;
+ default:
+ break;
+ }
+ }
+ else if (strcmp (option->name, SANE_NAME_PAGE_WIDTH) == 0) {
+ if (job->page_width > 0.0) {
+ if (option->type == SANE_TYPE_FIXED)
+ set_fixed_option (scanner->priv->handle, option, option_index, job->page_width / 10.0, NULL);
+ else
+ set_int_option (scanner->priv->handle, option, option_index, job->page_width / 10, NULL);
+ }
+ }
+ else if (strcmp (option->name, SANE_NAME_PAGE_HEIGHT) == 0) {
+ if (job->page_height > 0.0) {
+ if (option->type == SANE_TYPE_FIXED)
+ set_fixed_option (scanner->priv->handle, option, option_index, job->page_height / 10.0, NULL);
+ else
+ set_int_option (scanner->priv->handle, option, option_index, job->page_height / 10, NULL);
+ }
+ }
+
+ /* Test scanner options (hoping will not effect other scanners...) */
+ if (strcmp (scanner->priv->current_device, "test") == 0) {
+ if (strcmp (option->name, "hand-scanner") == 0) {
+ set_bool_option (scanner->priv->handle, option, option_index, FALSE, NULL);
+ }
+ else if (strcmp (option->name, "three-pass") == 0) {
+ set_bool_option (scanner->priv->handle, option, option_index, FALSE, NULL);
+ }
+ else if (strcmp (option->name, "test-picture") == 0) {
+ set_string_option (scanner->priv->handle, option, option_index, "Color pattern", NULL);
+ }
+ else if (strcmp (option->name, "read-delay") == 0) {
+ set_bool_option (scanner->priv->handle, option, option_index, TRUE, NULL);
+ }
+ else if (strcmp (option->name, "read-delay-duration") == 0) {
+ set_int_option (scanner->priv->handle, option, option_index, 200000, NULL);
+ }
+ }
+}
+
+
+static void
+do_complete_document (Scanner *scanner)
+{
+ ScanJob *job;
+
+ job = (ScanJob *) scanner->priv->job_queue->data;
+ g_free (job->device);
+ g_free (job);
+ scanner->priv->job_queue = g_list_remove_link (scanner->priv->job_queue, scanner->priv->job_queue);
+
+ scanner->priv->state = STATE_IDLE;
+
+ /* Continue onto the next job */
+ if (scanner->priv->job_queue) {
+ scanner->priv->state = STATE_OPEN;
+ return;
+ }
+
+ /* Trigger timeout to close */
+ // TODO
+
+ emit_signal (scanner, DOCUMENT_DONE, NULL);
+ set_scanning (scanner, FALSE);
+}
+
+
+static void
+do_start (Scanner *scanner)
+{
+ SANE_Status status;
+
+ emit_signal (scanner, EXPECT_PAGE, NULL);
+
+ status = sane_start (scanner->priv->handle);
+ g_debug ("sane_start (page=%d, pass=%d) -> %s", scanner->priv->page_number, scanner->priv->pass_number, get_status_string (status));
+ if (status == SANE_STATUS_GOOD) {
+ scanner->priv->state = STATE_GET_PARAMETERS;
+ }
+ else if (status == SANE_STATUS_NO_DOCS) {
+ do_complete_document (scanner);
+ }
+ else {
+ g_warning ("Unable to start device: %s", sane_strstatus (status));
+ fail_scan (scanner, status,
+ /* Error display when unable to start scan */
+ _("Unable to start scan"));
+ }
+}
+
+
+static void
+do_get_parameters (Scanner *scanner)
+{
+ SANE_Status status;
+ ScanPageInfo *info;
+ ScanJob *job;
+
+ status = sane_get_parameters (scanner->priv->handle, &scanner->priv->parameters);
+ g_debug ("sane_get_parameters () -> %s", get_status_string (status));
+ if (status != SANE_STATUS_GOOD) {
+ g_warning ("Unable to get device parameters: %s", sane_strstatus (status));
+ fail_scan (scanner, status,
+ /* Error displayed when communication with scanner broken */
+ _("Error communicating with scanner"));
+ return;
+ }
+
+ job = (ScanJob *) scanner->priv->job_queue->data;
+
+ g_debug ("Parameters: format=%s last_frame=%s bytes_per_line=%d pixels_per_line=%d lines=%d depth=%d",
+ get_frame_string (scanner->priv->parameters.format),
+ scanner->priv->parameters.last_frame ? "SANE_TRUE" : "SANE_FALSE",
+ scanner->priv->parameters.bytes_per_line,
+ scanner->priv->parameters.pixels_per_line,
+ scanner->priv->parameters.lines,
+ scanner->priv->parameters.depth);
+
+ info = g_malloc(sizeof(ScanPageInfo));
+ info->width = scanner->priv->parameters.pixels_per_line;
+ info->height = scanner->priv->parameters.lines;
+ info->depth = scanner->priv->parameters.depth;
+ info->dpi = job->dpi; // FIXME: This is the requested DPI, not the actual DPI
+ info->device = g_strdup (scanner->priv->current_device);
+
+ if (scanner->priv->page_number != scanner->priv->notified_page) {
+ emit_signal (scanner, GOT_PAGE_INFO, info);
+ scanner->priv->notified_page = scanner->priv->page_number;
+ }
+
+ /* Prepare for read */
+ scanner->priv->buffer_size = scanner->priv->parameters.bytes_per_line + 1; /* Use +1 so buffer is not resized if driver returns one line per read */
+ scanner->priv->buffer = g_malloc (sizeof(SANE_Byte) * scanner->priv->buffer_size);
+ scanner->priv->n_used = 0;
+ scanner->priv->line_count = 0;
+ scanner->priv->pass_number = 0;
+ scanner->priv->state = STATE_READ;
+}
+
+
+static void
+do_complete_page (Scanner *scanner)
+{
+ ScanJob *job;
+
+ emit_signal (scanner, PAGE_DONE, NULL);
+
+ job = (ScanJob *) scanner->priv->job_queue->data;
+
+ /* If multi-pass then scan another page */
+ if (!scanner->priv->parameters.last_frame) {
+ scanner->priv->pass_number++;
+ scanner->priv->state = STATE_START;
+ return;
+ }
+
+ /* Go back for another page */
+ if (job->type != SCAN_SINGLE) {
+ scanner->priv->page_number++;
+ scanner->priv->pass_number = 0;
+ emit_signal (scanner, PAGE_DONE, NULL);
+ scanner->priv->state = STATE_START;
+ return;
+ }
+
+ sane_cancel (scanner->priv->handle);
+ g_debug ("sane_cancel ()");
+
+ do_complete_document (scanner);
+}
+
+
+static void
+do_read (Scanner *scanner)
+{
+ SANE_Status status;
+ SANE_Int n_to_read, n_read;
+ gboolean full_read = FALSE;
+
+ /* Read as many bytes as we expect */
+ n_to_read = scanner->priv->buffer_size - scanner->priv->n_used;
+
+ status = sane_read (scanner->priv->handle,
+ scanner->priv->buffer + scanner->priv->n_used,
+ n_to_read, &n_read);
+ g_debug ("sane_read (%d) -> (%s, %d)", n_to_read, get_status_string (status), n_read);
+
+ /* End of variable length frame */
+ if (status == SANE_STATUS_EOF &&
+ scanner->priv->parameters.lines == -1 &&
+ scanner->priv->bytes_remaining == scanner->priv->parameters.bytes_per_line) {
+ do_complete_page (scanner);
+ return;
+ }
+
+ /* Communication error */
+ if (status != SANE_STATUS_GOOD) {
+ g_warning ("Unable to read frame from device: %s", sane_strstatus (status));
+ fail_scan (scanner, status,
+ /* Error displayed when communication with scanner broken */
+ _("Error communicating with scanner"));
+ return;
+ }
+
+ if (scanner->priv->n_used == 0 && n_read == scanner->priv->buffer_size)
+ full_read = TRUE;
+ scanner->priv->n_used += n_read;
+
+ /* Feed out lines */
+ if (scanner->priv->n_used >= scanner->priv->parameters.bytes_per_line) {
+ ScanLine *line;
+
+ line = g_malloc(sizeof(ScanLine));
+ switch (scanner->priv->parameters.format) {
+ case SANE_FRAME_GRAY:
+ line->format = LINE_GRAY;
+ break;
+ case SANE_FRAME_RGB:
+ line->format = LINE_RGB;
+ break;
+ case SANE_FRAME_RED:
+ line->format = LINE_RED;
+ break;
+ case SANE_FRAME_GREEN:
+ line->format = LINE_GREEN;
+ break;
+ case SANE_FRAME_BLUE:
+ line->format = LINE_BLUE;
+ break;
+ }
+ line->width = scanner->priv->parameters.pixels_per_line;
+ line->depth = scanner->priv->parameters.depth;
+ line->data = scanner->priv->buffer;
+ line->data_length = scanner->priv->parameters.bytes_per_line;
+ line->number = scanner->priv->line_count;
+ line->n_lines = scanner->priv->n_used / line->data_length;
+
+ scanner->priv->buffer = NULL;
+ scanner->priv->line_count += line->n_lines;
+
+ /* On last line */
+ if (scanner->priv->parameters.lines > 0 && scanner->priv->line_count >= scanner->priv->parameters.lines) {
+ emit_signal (scanner, GOT_LINE, line);
+ do_complete_page (scanner);
+ }
+ else {
+ int i, n_remaining;
+
+ /* Increase buffer size if did full read */
+ if (full_read)
+ scanner->priv->buffer_size += scanner->priv->parameters.bytes_per_line;
+
+ scanner->priv->buffer = g_malloc(sizeof(SANE_Byte) * scanner->priv->buffer_size);
+ n_remaining = scanner->priv->n_used - (line->n_lines * line->data_length);
+ scanner->priv->n_used = 0;
+ for (i = 0; i < n_remaining; i++) {
+ scanner->priv->buffer[i] = line->data[i + (line->n_lines * line->data_length)];
+ scanner->priv->n_used++;
+ }
+ emit_signal (scanner, GOT_LINE, line);
+ }
+ }
+}
+
+
+static gpointer
+scan_thread (Scanner *scanner)
+{
+ SANE_Status status;
+ SANE_Int version_code;
+
+ g_hash_table_insert (scanners, g_thread_self (), scanner);
+
+ scanner->priv->state = STATE_IDLE;
+
+ status = sane_init (&version_code, authorization_cb);
+ g_debug ("sane_init () -> %s", get_status_string (status));
+ if (status != SANE_STATUS_GOOD) {
+ g_warning ("Unable to initialize SANE backend: %s", sane_strstatus(status));
+ return FALSE;
+ }
+ g_debug ("SANE version %d.%d.%d",
+ SANE_VERSION_MAJOR(version_code),
+ SANE_VERSION_MINOR(version_code),
+ SANE_VERSION_BUILD(version_code));
+
+ /* Scan for devices on first start */
+ scanner_redetect (scanner);
+
+ while (handle_requests (scanner)) {
+ switch (scanner->priv->state) {
+ case STATE_IDLE:
+ if (scanner->priv->job_queue) {
+ set_scanning (scanner, TRUE);
+ scanner->priv->state = STATE_OPEN;
+ }
+ break;
+ case STATE_REDETECT:
+ do_redetect (scanner);
+ break;
+ case STATE_OPEN:
+ do_open (scanner);
+ break;
+ case STATE_GET_OPTION:
+ do_get_option (scanner);
+ break;
+ case STATE_START:
+ do_start (scanner);
+ break;
+ case STATE_GET_PARAMETERS:
+ do_get_parameters (scanner);
+ break;
+ case STATE_READ:
+ do_read (scanner);
+ break;
+ }
+ }
+
+ return NULL;
+}
+
+
+Scanner *
+scanner_new ()
+{
+ return g_object_new (SCANNER_TYPE, NULL);
+}
+
+
+void
+scanner_start (Scanner *scanner)
+{
+ GError *error = NULL;
+ scanner->priv->thread = g_thread_create ((GThreadFunc) scan_thread, scanner, TRUE, &error);
+ if (error) {
+ g_critical ("Unable to create thread: %s", error->message);
+ g_error_free (error);
+ }
+}
+
+
+void
+scanner_redetect (Scanner *scanner)
+{
+ ScanRequest *request;
+
+ if (scanner->priv->redetect)
+ return;
+ scanner->priv->redetect = TRUE;
+
+ g_debug ("Requesting redetection of scan devices");
+
+ request = g_malloc0 (sizeof (ScanRequest));
+ request->type = REQUEST_REDETECT;
+ g_async_queue_push (scanner->priv->scan_queue, request);
+}
+
+
+gboolean
+scanner_is_scanning (Scanner *scanner)
+{
+ return scanner->priv->scanning;
+}
+
+
+void
+scanner_scan (Scanner *scanner, const char *device, ScanOptions *options)
+{
+ ScanRequest *request;
+ const gchar *type_string;
+
+ switch (options->type) {
+ case SCAN_SINGLE:
+ type_string = "SCAN_SINGLE";
+ break;
+ case SCAN_ADF_FRONT:
+ type_string = "SCAN_ADF_FRONT";
+ break;
+ case SCAN_ADF_BACK:
+ type_string = "SCAN_ADF_BACK";
+ break;
+ case SCAN_ADF_BOTH:
+ type_string = "SCAN_ADF_BOTH";
+ break;
+ default:
+ g_assert (FALSE);
+ return;
+ }
+
+ g_debug ("scanner_scan (\"%s\", %d, %s)", device ? device : "(null)", options->dpi, type_string);
+ request = g_malloc0 (sizeof (ScanRequest));
+ request->type = REQUEST_START_SCAN;
+ request->job = g_malloc0 (sizeof (ScanJob));
+ request->job->device = g_strdup (device);
+ request->job->dpi = options->dpi;
+ request->job->scan_mode = options->scan_mode;
+ request->job->depth = options->depth;
+ request->job->type = options->type;
+ request->job->page_width = options->paper_width;
+ request->job->page_height = options->paper_height;
+ g_async_queue_push (scanner->priv->scan_queue, request);
+}
+
+
+void
+scanner_cancel (Scanner *scanner)
+{
+ ScanRequest *request;
+
+ request = g_malloc0 (sizeof (ScanRequest));
+ request->type = REQUEST_CANCEL;
+ g_async_queue_push (scanner->priv->scan_queue, request);
+}
+
+
+void scanner_free (Scanner *scanner)
+{
+ ScanRequest *request;
+
+ g_debug ("Stopping scan thread");
+
+ request = g_malloc0 (sizeof (ScanRequest));
+ request->type = REQUEST_QUIT;
+ g_async_queue_push (scanner->priv->scan_queue, request);
+
+ if (scanner->priv->thread)
+ g_thread_join (scanner->priv->thread);
+
+ g_async_queue_unref (scanner->priv->scan_queue);
+ g_object_unref (scanner);
+
+ sane_exit ();
+ g_debug ("sane_exit ()");
+}
+
+
+static void
+scanner_class_init (ScannerClass *klass)
+{
+ signals[AUTHORIZE] =
+ g_signal_new ("authorize",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, authorize),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__STRING,
+ G_TYPE_NONE, 1, G_TYPE_STRING);
+ signals[UPDATE_DEVICES] =
+ g_signal_new ("update-devices",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, update_devices),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[EXPECT_PAGE] =
+ g_signal_new ("expect-page",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, expect_page),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[GOT_PAGE_INFO] =
+ g_signal_new ("got-page-info",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, got_page_info),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[GOT_LINE] =
+ g_signal_new ("got-line",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, got_line),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[SCAN_FAILED] =
+ g_signal_new ("scan-failed",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, scan_failed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[PAGE_DONE] =
+ g_signal_new ("page-done",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, page_done),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[DOCUMENT_DONE] =
+ g_signal_new ("document-done",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, document_done),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[SCANNING_CHANGED] =
+ g_signal_new ("scanning-changed",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (ScannerClass, scanning_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ g_type_class_add_private (klass, sizeof (ScannerPrivate));
+
+ scanners = g_hash_table_new (g_direct_hash, g_direct_equal);
+}
+
+
+static void
+scanner_init (Scanner *scanner)
+{
+ scanner->priv = G_TYPE_INSTANCE_GET_PRIVATE (scanner, SCANNER_TYPE, ScannerPrivate);
+ scanner->priv->scan_queue = g_async_queue_new ();
+ scanner->priv->authorize_queue = g_async_queue_new ();
+}