Imported Upstream version 0.9.10upstream/0.9.10

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 ();
+}