From 4724f0995615090f13b8f31d687581afcf6a80f6 Mon Sep 17 00:00:00 2001 From: Frank Zago Date: Wed, 20 Mar 2002 00:07:35 +0000 Subject: [PATCH] Fixed indentation. No changes. --- backend/matsushita.c | 3246 ++++++++++++++++++++++-------------------- backend/matsushita.h | 202 +-- 2 files changed, 1810 insertions(+), 1638 deletions(-) diff --git a/backend/matsushita.c b/backend/matsushita.c index 33615c970..adb7c47a7 100644 --- a/backend/matsushita.c +++ b/backend/matsushita.c @@ -52,7 +52,7 @@ /*--------------------------------------------------------------------------*/ -#define BUILD 5 /* 2002-03-05 */ +#define BUILD 5 /* 2002-03-05 */ #define BACKEND_NAME matsushita #define MATSUSHITA_CONFIG_FILE "matsushita.conf" @@ -85,17 +85,17 @@ /*--------------------------------------------------------------------------*/ /* Lists of possible scan modes. */ -static SANE_String_Const scan_mode_list_1[] = { - HALFTONE_STR, - NULL +static SANE_String_Const scan_mode_list_1[] = { + HALFTONE_STR, + NULL }; -static SANE_String_Const scan_mode_list_3[] = { - BLACK_WHITE_STR, - HALFTONE_STR, - GRAY4_STR, - GRAY8_STR, - NULL +static SANE_String_Const scan_mode_list_3[] = { + BLACK_WHITE_STR, + HALFTONE_STR, + GRAY4_STR, + GRAY8_STR, + NULL }; /*--------------------------------------------------------------------------*/ @@ -110,25 +110,25 @@ static SANE_String_Const scan_mode_list_3[] = { */ #ifdef unused_yet static const SANE_Word resolutions_list_200[4] = { - 3, 100, 150, 200 + 3, 100, 150, 200 }; static const SANE_Word resolutions_rounds_200[4] = { - 3, 0x100, 0x40, 0x20 + 3, 0x100, 0x40, 0x20 }; #endif static const SANE_Word resolutions_list_300[5] = { - 4, 150, 200, 240, 300 + 4, 150, 200, 240, 300 }; static const SANE_Word resolutions_rounds_300[5] = { - 4, 0x100, 0x40, 0x20, 0x80 + 4, 0x100, 0x40, 0x20, 0x80 }; static const SANE_Word resolutions_list_400[8] = { - 7, 100, 150, 200, 240, 300, 360, 400 + 7, 100, 150, 200, 240, 300, 360, 400 }; static const SANE_Word resolutions_rounds_400[8] = { - 7, 0x100, 0x100, 0x40, 0x20, 0x80, 0x100, 0x100 /* TO FIX */ + 7, 0x100, 0x100, 0x40, 0x20, 0x80, 0x100, 0x100 /* TO FIX */ }; /*--------------------------------------------------------------------------*/ @@ -136,132 +136,132 @@ static const SANE_Word resolutions_rounds_400[8] = { /* Lists of supported halftone. They are only valid with * for the Black&White mode. */ static SANE_String_Const halftone_pattern_list[] = { - SANE_I18N("None"), - SANE_I18N("Bayer Dither 16"), - SANE_I18N("Bayer Dither 64"), - SANE_I18N("Halftone Dot 32"), - SANE_I18N("Halftone Dot 64"), - SANE_I18N("Error Diffusion"), - NULL + SANE_I18N ("None"), + SANE_I18N ("Bayer Dither 16"), + SANE_I18N ("Bayer Dither 64"), + SANE_I18N ("Halftone Dot 32"), + SANE_I18N ("Halftone Dot 64"), + SANE_I18N ("Error Diffusion"), + NULL }; static const int halftone_pattern_val[] = { - -1, - 0x01, - 0x00, - 0x02, - 0x03, - 0x04 + -1, + 0x01, + 0x00, + 0x02, + 0x03, + 0x04 }; /*--------------------------------------------------------------------------*/ /* List of automatic threshold options */ static SANE_String_Const automatic_threshold_list[] = { - SANE_I18N("None"), - SANE_I18N("Mode 1"), - SANE_I18N("Mode 2"), - SANE_I18N("Mode 3"), - NULL + SANE_I18N ("None"), + SANE_I18N ("Mode 1"), + SANE_I18N ("Mode 2"), + SANE_I18N ("Mode 3"), + NULL }; static const int automatic_threshold_val[] = { - 0, - 0x80, - 0x81, - 0x82 + 0, + 0x80, + 0x81, + 0x82 }; /*--------------------------------------------------------------------------*/ /* List of white level base. */ static SANE_String_Const white_level_list[] = { - SANE_I18N("From white stick"), - SANE_I18N("From paper"), - SANE_I18N("Automatic"), - NULL + SANE_I18N ("From white stick"), + SANE_I18N ("From paper"), + SANE_I18N ("Automatic"), + NULL }; static const int white_level_val[] = { - 0x00, - 0x80, - 0x81 + 0x00, + 0x80, + 0x81 }; /*--------------------------------------------------------------------------*/ /* List of noise reduction options. */ static SANE_String_Const noise_reduction_list[] = { - SANE_I18N("None"), - "1x1", - "2x2", - "3x3", - "4x4", - "5x5", - NULL + SANE_I18N ("None"), + "1x1", + "2x2", + "3x3", + "4x4", + "5x5", + NULL }; static const int noise_reduction_val[] = { - 0x00, - 0x01, - 0x02, - 0x03, - 0x04, - 0x05 + 0x00, + 0x01, + 0x02, + 0x03, + 0x04, + 0x05 }; /*--------------------------------------------------------------------------*/ /* List of image emphasis options, 5 steps */ static SANE_String_Const image_emphasis_list_5[] = { - SANE_I18N("Smooth"), - SANE_I18N("None"), - SANE_I18N("Low"), - SANE_I18N("Medium"), /* default */ - SANE_I18N("High"), - NULL + SANE_I18N ("Smooth"), + SANE_I18N ("None"), + SANE_I18N ("Low"), + SANE_I18N ("Medium"), /* default */ + SANE_I18N ("High"), + NULL }; static const int image_emphasis_val_5[] = { - 0x80, - 0x00, - 0x01, - 0x30, - 0x50 + 0x80, + 0x00, + 0x01, + 0x30, + 0x50 }; /* List of image emphasis options, 3 steps */ static SANE_String_Const image_emphasis_list_3[] = { - SANE_I18N("Low"), - SANE_I18N("Medium"), /* default ? */ - SANE_I18N("High"), - NULL + SANE_I18N ("Low"), + SANE_I18N ("Medium"), /* default ? */ + SANE_I18N ("High"), + NULL }; static const int image_emphasis_val_3[] = { - 0x01, - 0x30, - 0x50 + 0x01, + 0x30, + 0x50 }; /*--------------------------------------------------------------------------*/ /* List of gamma */ static SANE_String_Const gamma_list[] = { - SANE_I18N("Normal"), - SANE_I18N("CRT"), - NULL + SANE_I18N ("Normal"), + SANE_I18N ("CRT"), + NULL }; static const int gamma_val[] = { - 0x00, - 0x01 + 0x00, + 0x01 }; /*--------------------------------------------------------------------------*/ /* Page feeder options */ static SANE_String_Const feeder_mode_list[] = { - SANE_I18N("One page"), - SANE_I18N("All pages"), - NULL + SANE_I18N ("One page"), + SANE_I18N ("All pages"), + NULL }; static const int feeder_mode_val[] = { - 0x00, - 0xff + 0x00, + 0xff }; /*--------------------------------------------------------------------------*/ @@ -269,43 +269,43 @@ static const int feeder_mode_val[] = { /* Paper size in millimeters. * Values from http://www.twics.com/~eds/paper/. */ static const struct paper_sizes paper_sizes[] = { - { "2A0", 1189, 1682 }, - { "4A0", 1682, 2378 }, - { "A0", 841, 1189 }, - { "A1", 594, 841 }, - { "A2", 420, 594 }, - { "A3", 297, 420 }, - { "A4", 210, 297 }, - { "A5", 148, 210 }, - { "A6", 105, 148 }, - { "A7", 74, 105 }, - { "A8", 52, 74 }, - { "A9", 37, 52 }, - { "A10", 26, 37 }, - { "B0", 1000, 1414 }, - { "B1", 707, 1000 }, - { "B2", 500, 707 }, - { "B3", 353, 500 }, - { "B4", 250, 353 }, - { "B5", 176, 250 }, - { "B6", 125, 176 }, - { "B7", 88, 125 }, - { "B8", 62, 88 }, - { "B9", 44, 62 }, - { "B10", 31, 44 }, - { "C0", 917, 1297 }, - { "C1", 648, 917 }, - { "C2", 458, 648 }, - { "C3", 324, 458 }, - { "C4", 229, 324 }, - { "C5", 162, 229 }, - { "C6", 114, 162 }, - { "C7", 81, 114 }, - { "C8", 57, 81 }, - { "C9", 40, 57 }, - { "C10", 28, 40 }, - { "Legal", 8.5 * MM_PER_INCH, 14 * MM_PER_INCH }, - { "Letter", 8.5 * MM_PER_INCH, 11 * MM_PER_INCH } + {"2A0", 1189, 1682}, + {"4A0", 1682, 2378}, + {"A0", 841, 1189}, + {"A1", 594, 841}, + {"A2", 420, 594}, + {"A3", 297, 420}, + {"A4", 210, 297}, + {"A5", 148, 210}, + {"A6", 105, 148}, + {"A7", 74, 105}, + {"A8", 52, 74}, + {"A9", 37, 52}, + {"A10", 26, 37}, + {"B0", 1000, 1414}, + {"B1", 707, 1000}, + {"B2", 500, 707}, + {"B3", 353, 500}, + {"B4", 250, 353}, + {"B5", 176, 250}, + {"B6", 125, 176}, + {"B7", 88, 125}, + {"B8", 62, 88}, + {"B9", 44, 62}, + {"B10", 31, 44}, + {"C0", 917, 1297}, + {"C1", 648, 917}, + {"C2", 458, 648}, + {"C3", 324, 458}, + {"C4", 229, 324}, + {"C5", 162, 229}, + {"C6", 114, 162}, + {"C7", 81, 114}, + {"C8", 57, 81}, + {"C9", 40, 57}, + {"C10", 28, 40}, + {"Legal", 8.5 * MM_PER_INCH, 14 * MM_PER_INCH}, + {"Letter", 8.5 * MM_PER_INCH, 11 * MM_PER_INCH} }; /*--------------------------------------------------------------------------*/ @@ -313,120 +313,113 @@ static const struct paper_sizes paper_sizes[] = { /* Define the supported scanners and their characteristics. */ static const struct scanners_supported scanners[] = { - /* Panasonic KV-SS25 */ - { - 0x06, "K.M.E. ", "KV-SS25A ", - { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0 }, /* y range 0 to 431.8 mm */ - { 1, 255, 1 }, /* brightness range */ - { 1, 255, 1 }, /* contrast range */ - scan_mode_list_3, - resolutions_list_300, resolutions_rounds_300, - image_emphasis_list_5, image_emphasis_val_5, - MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | - MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | - MAT_CAP_NOISE_REDUCTION - }, + /* Panasonic KV-SS25 */ + { + 0x06, "K.M.E. ", "KV-SS25A ", + {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */ + {1, 255, 1}, /* brightness range */ + {1, 255, 1}, /* contrast range */ + scan_mode_list_3, + resolutions_list_300, resolutions_rounds_300, + image_emphasis_list_5, image_emphasis_val_5, + MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | + MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | + MAT_CAP_NOISE_REDUCTION}, - /* Panasonic KV-SS25D */ - { - 0x06, "K.M.E. ", "KV-SS25D ", /* TO FIX */ - { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0 }, /* y range 0 to 431.8 mm */ - { 1, 255, 1 }, /* brightness range */ - { 1, 255, 1 }, /* contrast range */ - scan_mode_list_3, - resolutions_list_300, resolutions_rounds_300, - image_emphasis_list_5, image_emphasis_val_5, - MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | - MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | - MAT_CAP_NOISE_REDUCTION - }, + /* Panasonic KV-SS25D */ + { + 0x06, "K.M.E. ", "KV-SS25D ", /* TO FIX */ + {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 431.8 mm */ + {1, 255, 1}, /* brightness range */ + {1, 255, 1}, /* contrast range */ + scan_mode_list_3, + resolutions_list_300, resolutions_rounds_300, + image_emphasis_list_5, image_emphasis_val_5, + MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | + MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | + MAT_CAP_NOISE_REDUCTION}, - /* Panasonic KV-SS50 */ - { - 0x06, "K.M.E. ", "KV-SS50 ", /* TO FIX */ - { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (14 * MM_PER_INCH), 0 }, /* y range 0 to 355.6 mm */ - { 1, 5, 1 }, /* brightness range, TO FIX */ - { 0, 0, 0 }, /* contrast range */ - scan_mode_list_1, - resolutions_list_300, resolutions_rounds_300, /* TO FIX */ - image_emphasis_list_3, image_emphasis_val_3, - MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE - }, + /* Panasonic KV-SS50 */ + { + 0x06, "K.M.E. ", "KV-SS50 ", /* TO FIX */ + {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (14 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */ + {1, 5, 1}, /* brightness range, TO FIX */ + {0, 0, 0}, /* contrast range */ + scan_mode_list_1, + resolutions_list_300, resolutions_rounds_300, /* TO FIX */ + image_emphasis_list_3, image_emphasis_val_3, + MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE}, - /* Panasonic KV-SS55 */ - { - 0x06, "K.M.E. ", "KV-SS55 ", /* TO FIX */ - { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (14 * MM_PER_INCH), 0 }, /* y range 0 to 355.6 mm */ - { 1, 5, 1 }, /* brightness range, TO FIX */ - { 1, 255, 1 }, /* contrast range, TO FIX */ - scan_mode_list_1, - resolutions_list_300, resolutions_rounds_300, /* TO FIX */ - image_emphasis_list_3, image_emphasis_val_3, - MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE - }, + /* Panasonic KV-SS55 */ + { + 0x06, "K.M.E. ", "KV-SS55 ", /* TO FIX */ + {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (14 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */ + {1, 5, 1}, /* brightness range, TO FIX */ + {1, 255, 1}, /* contrast range, TO FIX */ + scan_mode_list_1, + resolutions_list_300, resolutions_rounds_300, /* TO FIX */ + image_emphasis_list_3, image_emphasis_val_3, + MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_PAPER_DETECT | + MAT_CAP_MIRROR_IMAGE}, - /* Panasonic KV-SS50EX */ - { - 0x06, "K.M.E. ", "KV-SS50EX ", /* TO FIX */ - { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0 }, /* y range 0 to 355.6 mm */ - { 1, 255, 1 }, /* brightness range */ - { 0, 0, 0 }, /* contrast range */ - scan_mode_list_3, - resolutions_list_300, resolutions_rounds_300, /* TO FIX */ - image_emphasis_list_5, image_emphasis_val_5, - MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | - MAT_CAP_NOISE_REDUCTION | MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE - }, + /* Panasonic KV-SS50EX */ + { + 0x06, "K.M.E. ", "KV-SS50EX ", /* TO FIX */ + {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */ + {1, 255, 1}, /* brightness range */ + {0, 0, 0}, /* contrast range */ + scan_mode_list_3, + resolutions_list_300, resolutions_rounds_300, /* TO FIX */ + image_emphasis_list_5, image_emphasis_val_5, + MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | + MAT_CAP_NOISE_REDUCTION | MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE}, - /* Panasonic KV-SS55EX */ - { - 0x06, "K.M.E. ", "KV-SS55EX ", /* TO FIX */ - { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0 }, /* y range 0 to 355.6 mm */ - { 1, 255, 1 }, /* brightness range */ - { 1, 255, 1 }, /* contrast range, TO FIX */ - scan_mode_list_3, - resolutions_list_300, resolutions_rounds_300, /* TO FIX */ - image_emphasis_list_5, image_emphasis_val_5, - MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_AUTOMATIC_THRESHOLD | - MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION | - MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE - }, + /* Panasonic KV-SS55EX */ + { + 0x06, "K.M.E. ", "KV-SS55EX ", /* TO FIX */ + {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */ + {1, 255, 1}, /* brightness range */ + {1, 255, 1}, /* contrast range, TO FIX */ + scan_mode_list_3, + resolutions_list_300, resolutions_rounds_300, /* TO FIX */ + image_emphasis_list_5, image_emphasis_val_5, + MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_AUTOMATIC_THRESHOLD | + MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION | + MAT_CAP_PAPER_DETECT | MAT_CAP_MIRROR_IMAGE}, - /* Panasonic KV-SS850 */ - { - 0x06, "K.M.E. ", "KV-SS850 ", /* TO FIX */ - { SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0 }, /* y range 0 to 355.6 mm */ - { 1, 255, 1 }, /* brightness range */ - { 0, 0, 0 }, /* contrast range */ - scan_mode_list_3, - resolutions_list_300, resolutions_rounds_300, /* TO FIX */ - image_emphasis_list_5, image_emphasis_val_5, - MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | - MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION | MAT_CAP_PAPER_DETECT | - MAT_CAP_DETECT_DOUBLE_FEED | MAT_CAP_MANUAL_FEED - }, + /* Panasonic KV-SS850 */ + { + 0x06, "K.M.E. ", "KV-SS850 ", /* TO FIX */ + {SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */ + {1, 255, 1}, /* brightness range */ + {0, 0, 0}, /* contrast range */ + scan_mode_list_3, + resolutions_list_300, resolutions_rounds_300, /* TO FIX */ + image_emphasis_list_5, image_emphasis_val_5, + MAT_CAP_AUTOMATIC_THRESHOLD | MAT_CAP_WHITE_LEVEL | + MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION | MAT_CAP_PAPER_DETECT | + MAT_CAP_DETECT_DOUBLE_FEED | MAT_CAP_MANUAL_FEED}, - /* Panasonic KV-SS855 */ - { - 0x06, "K.M.E. ", "KV-SS855 ", /* TO FIX */ - { SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0 }, /* x range 0 to 215.9 mm */ - { SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0 }, /* y range 0 to 355.6 mm */ - { 1, 255, 1 }, /* brightness range */ - { 1, 255, 1 }, /* contrast range, TO FIX */ - scan_mode_list_3, - resolutions_list_400, resolutions_rounds_400, /* TO FIX */ - image_emphasis_list_5, image_emphasis_val_5, - MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_AUTOMATIC_THRESHOLD | - MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION | MAT_CAP_PAPER_DETECT | - MAT_CAP_DETECT_DOUBLE_FEED | MAT_CAP_MANUAL_FEED - } + /* Panasonic KV-SS855 */ + { + 0x06, "K.M.E. ", "KV-SS855 ", /* TO FIX */ + {SANE_FIX (0), SANE_FIX (11.5 * MM_PER_INCH), 0}, /* x range 0 to 215.9 mm */ + {SANE_FIX (0), SANE_FIX (17 * MM_PER_INCH), 0}, /* y range 0 to 355.6 mm */ + {1, 255, 1}, /* brightness range */ + {1, 255, 1}, /* contrast range, TO FIX */ + scan_mode_list_3, + resolutions_list_400, resolutions_rounds_400, /* TO FIX */ + image_emphasis_list_5, image_emphasis_val_5, + MAT_CAP_DUPLEX | MAT_CAP_CONTRAST | MAT_CAP_AUTOMATIC_THRESHOLD | + MAT_CAP_WHITE_LEVEL | MAT_CAP_GAMMA | MAT_CAP_NOISE_REDUCTION | + MAT_CAP_PAPER_DETECT | MAT_CAP_DETECT_DOUBLE_FEED | MAT_CAP_MANUAL_FEED} }; @@ -444,76 +437,86 @@ static const SANE_Device **devlist = NULL; static void hexdump (int level, char *comment, unsigned char *p, int l) { - int i; - char line[128]; - char *ptr; + int i; + char line[128]; + char *ptr; - DBG (level, "%s\n", comment); - ptr = line; - for (i = 0; i < l; i++, p++) { - if ((i % 16) == 0) { - if (ptr != line) { - *ptr = '\0'; - DBG (level, "%s\n", line); - ptr = line; - } - sprintf (ptr, "%3.3d:", i); - ptr += 4; - } - sprintf (ptr, " %2.2x", *p); - ptr += 3; + DBG (level, "%s\n", comment); + ptr = line; + for (i = 0; i < l; i++, p++) + { + if ((i % 16) == 0) + { + if (ptr != line) + { + *ptr = '\0'; + DBG (level, "%s\n", line); + ptr = line; + } + sprintf (ptr, "%3.3d:", i); + ptr += 4; } - *ptr = '\0'; - DBG (level, "%s\n", line); + sprintf (ptr, " %2.2x", *p); + ptr += 3; + } + *ptr = '\0'; + DBG (level, "%s\n", line); } /* Returns the length of the longest string, including the terminating * character. */ -static size_t max_string_size(SANE_String_Const strings[]) +static size_t +max_string_size (SANE_String_Const strings[]) { - size_t size, max_size = 0; - int i; + size_t size, max_size = 0; + int i; - for (i = 0; strings[i]; ++i) { - size = strlen (strings[i]) + 1; - if (size > max_size) { - max_size = size; - } + for (i = 0; strings[i]; ++i) + { + size = strlen (strings[i]) + 1; + if (size > max_size) + { + max_size = size; } - - return max_size; + } + + return max_size; } /* After the windows has been set, issue that command to get the * document size. */ -static SANE_Status matsushita_read_document_size (Matsushita_Scanner *dev) +static SANE_Status +matsushita_read_document_size (Matsushita_Scanner * dev) { - CDB cdb; - SANE_Status status; - size_t size; + CDB cdb; + SANE_Status status; + size_t size; - DBG (DBG_proc, "matsushita_read_document_size: enter\n"); + DBG (DBG_proc, "matsushita_read_document_size: enter\n"); - size = 0x10; - MKSCSI_SCSI_READ_10 (cdb, 0x80, 0, size); + size = 0x10; + MKSCSI_SCSI_READ_10 (cdb, 0x80, 0, size); - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); + status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); - if (status != SANE_STATUS_GOOD || size != 0x10) { - DBG (DBG_error, "matsushita_read_document_size: cannot read document size\n"); - return (SANE_STATUS_IO_ERROR); - } + if (status != SANE_STATUS_GOOD || size != 0x10) + { + DBG (DBG_error, + "matsushita_read_document_size: cannot read document size\n"); + return (SANE_STATUS_IO_ERROR); + } - hexdump (DBG_info2, "document size", dev->buffer, 16); - - /* Check that X and Y are the same values the backend computed. */ + hexdump (DBG_info2, "document size", dev->buffer, 16); - assert(dev->params.lines == B32TOI(&dev->buffer[4])); - assert(dev->params.pixels_per_line == B32TOI(&dev->buffer[0])); + /* Check that X and Y are the same values the backend computed. */ - DBG (DBG_proc, "matsushita_read_document_size: exit, %d bytes read\n", size); + assert (dev->params.lines == B32TOI (&dev->buffer[4])); + assert (dev->params.pixels_per_line == B32TOI (&dev->buffer[0])); - return (SANE_STATUS_GOOD); + DBG (DBG_proc, "matsushita_read_document_size: exit, %d bytes read\n", + size); + + return (SANE_STATUS_GOOD); } /* Initialize a scanner entry. Return an allocated scanner with some @@ -521,667 +524,727 @@ static SANE_Status matsushita_read_document_size (Matsushita_Scanner *dev) static Matsushita_Scanner * matsushita_init (void) { - Matsushita_Scanner *dev; + Matsushita_Scanner *dev; - DBG (DBG_proc, "matsushita_init: enter\n"); + DBG (DBG_proc, "matsushita_init: enter\n"); - /* Allocate a new scanner entry. */ - dev = malloc (sizeof (Matsushita_Scanner)); - if (dev == NULL) { - return NULL; - } + /* Allocate a new scanner entry. */ + dev = malloc (sizeof (Matsushita_Scanner)); + if (dev == NULL) + { + return NULL; + } - memset (dev, 0, sizeof (Matsushita_Scanner)); + memset (dev, 0, sizeof (Matsushita_Scanner)); - /* Allocate the buffer used to transfer the SCSI data. */ - dev->buffer_size = 64 * 1024; - dev->buffer = malloc (dev->buffer_size); - if (dev->buffer == NULL) { - free (dev); - return NULL; - } + /* Allocate the buffer used to transfer the SCSI data. */ + dev->buffer_size = 64 * 1024; + dev->buffer = malloc (dev->buffer_size); + if (dev->buffer == NULL) + { + free (dev); + return NULL; + } - dev->sfd = -1; + dev->sfd = -1; - DBG (DBG_proc, "matsushita_init: exit\n"); + DBG (DBG_proc, "matsushita_init: exit\n"); - return (dev); + return (dev); } /* Closes an open scanner. */ static void matsushita_close (Matsushita_Scanner * dev) { - DBG (DBG_proc, "matsushita_close: enter\n"); + DBG (DBG_proc, "matsushita_close: enter\n"); - if (dev->sfd != -1) { - sanei_scsi_close (dev->sfd); - dev->sfd = -1; - } + if (dev->sfd != -1) + { + sanei_scsi_close (dev->sfd); + dev->sfd = -1; + } - DBG (DBG_proc, "matsushita_close: exit\n"); + DBG (DBG_proc, "matsushita_close: exit\n"); } /* Frees the memory used by a scanner. */ static void matsushita_free (Matsushita_Scanner * dev) { - DBG (DBG_proc, "matsushita_free: enter\n"); + DBG (DBG_proc, "matsushita_free: enter\n"); - if (dev == NULL) - return; + if (dev == NULL) + return; - matsushita_close (dev); - if (dev->devicename) { - free (dev->devicename); - } - if (dev->buffer) { - free (dev->buffer); - } - if (dev->image == NULL) { - free (dev->image); - } + matsushita_close (dev); + if (dev->devicename) + { + free (dev->devicename); + } + if (dev->buffer) + { + free (dev->buffer); + } + if (dev->image == NULL) + { + free (dev->image); + } - free (dev); + free (dev); - DBG (DBG_proc, "matsushita_free: exit\n"); + DBG (DBG_proc, "matsushita_free: exit\n"); } /* Inquiry a device and returns TRUE if is supported. */ static int matsushita_identify_scanner (Matsushita_Scanner * dev) { - CDB cdb; - SANE_Status status; - size_t size; - int i; + CDB cdb; + SANE_Status status; + size_t size; + int i; - DBG (DBG_proc, "matsushita_identify_scanner: enter\n"); + DBG (DBG_proc, "matsushita_identify_scanner: enter\n"); - size = 5; - MKSCSI_INQUIRY (cdb, size); - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); + size = 5; + MKSCSI_INQUIRY (cdb, size); + status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); - if (status) { - DBG (DBG_error, - "matsushita_identify_scanner: inquiry failed with status %s\n", - sane_strstatus (status)); - return (SANE_FALSE); + if (status) + { + DBG (DBG_error, + "matsushita_identify_scanner: inquiry failed with status %s\n", + sane_strstatus (status)); + return (SANE_FALSE); + } + + size = dev->buffer[4] + 5; /* total length of the inquiry data */ + + if (size < 36) + { + DBG (DBG_error, + "matsushita_identify_scanner: not enough data to identify device\n"); + return (SANE_FALSE); + } + + MKSCSI_INQUIRY (cdb, size); + status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); + + if (status) + { + DBG (DBG_error, + "matsushita_identify_scanner: inquiry failed with status %s\n", + sane_strstatus (status)); + return (SANE_FALSE); + } + + hexdump (DBG_info2, "inquiry", dev->buffer, size); + + dev->scsi_type = dev->buffer[0] & 0x1f; + strncpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08); + dev->scsi_vendor[0x08] = 0; + strncpy (dev->scsi_product, dev->buffer + 0x10, 0x010); + dev->scsi_product[0x10] = 0; + strncpy (dev->scsi_version, dev->buffer + 0x20, 0x04); + dev->scsi_version[0x04] = 0; + + DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\"\n", + dev->scsi_vendor, dev->scsi_product, dev->scsi_version); + + /* Lookup through the supported scanners table to find if this + * backend supports that one. */ + for (i = 0; i < NELEMS (scanners); i++) + { + if (dev->scsi_type == scanners[i].scsi_type && + strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 && + strcmp (dev->scsi_product, scanners[i].scsi_product) == 0) + { + + DBG (DBG_error, "matsushita_identify_scanner: scanner supported\n"); + + dev->scnum = i; + + return (SANE_TRUE); } + } - size = dev->buffer[4] + 5; /* total length of the inquiry data */ + DBG (DBG_proc, "matsushita_identify_scanner: exit, device not supported\n"); - if (size < 36) { - DBG (DBG_error, - "matsushita_identify_scanner: not enough data to identify device\n"); - return (SANE_FALSE); - } - - MKSCSI_INQUIRY (cdb, size); - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); - - if (status) { - DBG (DBG_error, - "matsushita_identify_scanner: inquiry failed with status %s\n", - sane_strstatus (status)); - return (SANE_FALSE); - } - - hexdump (DBG_info2, "inquiry", dev->buffer, size); - - dev->scsi_type = dev->buffer[0] & 0x1f; - strncpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08); - dev->scsi_vendor[0x08] = 0; - strncpy (dev->scsi_product, dev->buffer + 0x10, 0x010); - dev->scsi_product[0x10] = 0; - strncpy (dev->scsi_version, dev->buffer + 0x20, 0x04); - dev->scsi_version[0x04] = 0; - - DBG (DBG_info, "device is \"%s\" \"%s\" \"%s\"\n", - dev->scsi_vendor, dev->scsi_product, dev->scsi_version); - - /* Lookup through the supported scanners table to find if this - * backend supports that one. */ - for (i = 0; i < NELEMS(scanners); i++) { - if (dev->scsi_type == scanners[i].scsi_type && - strcmp(dev->scsi_vendor, scanners[i].scsi_vendor) == 0 && - strcmp(dev->scsi_product, scanners[i].scsi_product) == 0) { - - DBG (DBG_error, - "matsushita_identify_scanner: scanner supported\n"); - - dev->scnum = i; - - return (SANE_TRUE); - } - } - - DBG (DBG_proc, "matsushita_identify_scanner: exit, device not supported\n"); - - return (SANE_FALSE); + return (SANE_FALSE); } /* The interface can show different paper sizes. Show only the sizes * available for that scanner. */ -static int matsushita_build_paper_sizes (Matsushita_Scanner * dev) +static int +matsushita_build_paper_sizes (Matsushita_Scanner * dev) { - SANE_String_Const *psl; /* string list */ - int *psv; /* value list */ - int num; - int i; + SANE_String_Const *psl; /* string list */ + int *psv; /* value list */ + int num; + int i; - DBG (DBG_proc, "matsushita_build_paper_sizes: enter\n"); + DBG (DBG_proc, "matsushita_build_paper_sizes: enter\n"); - psl = malloc((sizeof(SANE_String_Const) + 1) * NELEMS(paper_sizes)); - if (psl == NULL) { - DBG (DBG_error, "ERROR: not enough memory\n"); - return SANE_STATUS_NO_MEM; + psl = malloc ((sizeof (SANE_String_Const) + 1) * NELEMS (paper_sizes)); + if (psl == NULL) + { + DBG (DBG_error, "ERROR: not enough memory\n"); + return SANE_STATUS_NO_MEM; + } + + psv = malloc ((sizeof (int) + 1) * NELEMS (paper_sizes)); + if (psv == NULL) + { + DBG (DBG_error, "ERROR: not enough memory\n"); + free (psl); + return SANE_STATUS_NO_MEM; + } + + for (i = 0, num = 0; i < NELEMS (paper_sizes); i++) + { + if (SANE_UNFIX (scanners[dev->scnum].x_range.max) >= + paper_sizes[i].width + && SANE_UNFIX (scanners[dev->scnum].y_range.max) >= + paper_sizes[i].length) + { + + /* This paper size fits into the scanner. */ + psl[num] = paper_sizes[i].name; + psv[num] = i; + num++; } + } + psl[num] = NULL; /* terminate the list */ - psv = malloc((sizeof(int) + 1) * NELEMS(paper_sizes)); - if (psv == NULL) { - DBG (DBG_error, "ERROR: not enough memory\n"); - free(psl); - return SANE_STATUS_NO_MEM; - } + dev->paper_sizes_list = psl; + dev->paper_sizes_val = psv; - for (i = 0, num = 0; iscnum].x_range.max) >= paper_sizes[i].width && - SANE_UNFIX(scanners[dev->scnum].y_range.max) >= paper_sizes[i].length) { - - /* This paper size fits into the scanner. */ - psl[num] = paper_sizes[i].name; - psv[num] = i; - num ++; - } - } - psl[num] = NULL; /* terminate the list */ + DBG (DBG_proc, "matsushita_build_paper_sizes: exit (%d)\n", num); - dev->paper_sizes_list = psl; - dev->paper_sizes_val = psv; - - DBG (DBG_proc, "matsushita_build_paper_sizes: exit (%d)\n", num); - - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } /* Lookup a string list from one array and return its index. */ -static int get_string_list_index(SANE_String_Const list[], SANE_String_Const name) +static int +get_string_list_index (SANE_String_Const list[], SANE_String_Const name) { - int index; + int index; - index = 0; - while(list[index] != NULL) { - if (strcmp(list[index], name) == 0) { - return(index); - } - index++; + index = 0; + while (list[index] != NULL) + { + if (strcmp (list[index], name) == 0) + { + return (index); } + index++; + } - DBG (DBG_error, "name %s not found in list\n", name); + DBG (DBG_error, "name %s not found in list\n", name); - assert(0 == 1); /* bug in backend, core dump */ + assert (0 == 1); /* bug in backend, core dump */ - return(-1); + return (-1); } /* Lookup an int list from one array and return its index. */ -static int get_int_list_index(const SANE_Word list[], const SANE_Word value) +static int +get_int_list_index (const SANE_Word list[], const SANE_Word value) { - int index; - int size; /* number of elements */ + int index; + int size; /* number of elements */ - index = 1; - size = list[0]; - while (index <= size) { - if (list[index] == value) { - return(index); - } - index++; + index = 1; + size = list[0]; + while (index <= size) + { + if (list[index] == value) + { + return (index); } - - DBG (DBG_error, "word %d not found in list\n", value); - - assert(0 == 1); /* bug in backend, core dump */ + index++; + } - return(-1); + DBG (DBG_error, "word %d not found in list\n", value); + + assert (0 == 1); /* bug in backend, core dump */ + + return (-1); } /* SCSI sense handler. Callback for SANE. */ static SANE_Status matsushita_sense_handler (int scsi_fd, unsigned char *result, void *arg) { - int asc, ascq, sensekey; - int len; + int asc, ascq, sensekey; + int len; - DBG (DBG_proc, "matsushita_sense_handler (scsi_fd = %d)\n", scsi_fd); + DBG (DBG_proc, "matsushita_sense_handler (scsi_fd = %d)\n", scsi_fd); - arg = arg; /* silence gcc */ + arg = arg; /* silence gcc */ - sensekey = get_RS_sense_key(result); - len = 7 + get_RS_additional_length(result); + sensekey = get_RS_sense_key (result); + len = 7 + get_RS_additional_length (result); - hexdump (DBG_info2, "sense", result, len); + hexdump (DBG_info2, "sense", result, len); - if ( get_RS_error_code(result) != 0x70 ) { - DBG(DBG_error, "matsushita_sense_handler: invalid sense key error code (%d)\n", - get_RS_error_code(result)); + if (get_RS_error_code (result) != 0x70) + { + DBG (DBG_error, + "matsushita_sense_handler: invalid sense key error code (%d)\n", + get_RS_error_code (result)); - return SANE_STATUS_IO_ERROR; + return SANE_STATUS_IO_ERROR; + } + + if (get_RS_ILI (result) != 0) + { + DBG (DBG_sense, "matsushita_sense_handler: short read\n"); + } + + if (len < 14) + { + DBG (DBG_error, + "matsushita_sense_handler: sense too short, no ASC/ASCQ\n"); + + return SANE_STATUS_IO_ERROR; + } + + asc = get_RS_ASC (result); + ascq = get_RS_ASCQ (result); + + DBG (DBG_sense, "matsushita_sense_handler: sense=%d, ASC/ASCQ=%02x%02x\n", + sensekey, asc, ascq); + + switch (sensekey) + { + case 0x00: /* no sense */ + if (get_RS_EOM (result) && asc == 0x00 && ascq == 0x00) + { + DBG (DBG_sense, "matsushita_sense_handler: EOF\n"); + return SANE_STATUS_EOF; } - if (get_RS_ILI(result) != 0) { - DBG(DBG_sense, "matsushita_sense_handler: short read\n"); + return SANE_STATUS_GOOD; + break; + + case 0x02: /* not ready */ + if (asc == 0x04 && ascq == 0x81) + { + /* Jam door open. */ + return SANE_STATUS_COVER_OPEN; } + break; - if (len < 14) { - DBG(DBG_error, "matsushita_sense_handler: sense too short, no ASC/ASCQ\n"); - - return SANE_STATUS_IO_ERROR; + case 0x03: /* medium error */ + if (asc == 0x3a) + { + /* No paper in the feeder. */ + return SANE_STATUS_NO_DOCS; } - - asc = get_RS_ASC(result); - ascq = get_RS_ASCQ(result); - - DBG(DBG_sense, "matsushita_sense_handler: sense=%d, ASC/ASCQ=%02x%02x\n", - sensekey, asc, ascq); - - switch(sensekey) { - case 0x00: /* no sense */ - if (get_RS_EOM(result) && asc == 0x00 && ascq == 0x00) { - DBG(DBG_sense, "matsushita_sense_handler: EOF\n"); - return SANE_STATUS_EOF; - } - - return SANE_STATUS_GOOD; - break; - - case 0x02: /* not ready */ - if (asc == 0x04 && ascq == 0x81) { - /* Jam door open. */ - return SANE_STATUS_COVER_OPEN; - } - break; - - case 0x03: /* medium error */ - if (asc == 0x3a) { - /* No paper in the feeder. */ - return SANE_STATUS_NO_DOCS; - } - if (asc == 0x80) { - /* Probably a paper jam. ascq might give more info. */ - return SANE_STATUS_JAMMED; - } - break; - - case 0x05: - if (asc == 0x20 || asc == 0x24 || asc == 0x26) { - /* Invalid command, invalid field in CDB or invalid field in data. - * The backend has prepared some wrong combination of options. - * Shot the backend maintainer. */ - return SANE_STATUS_IO_ERROR; - } - else if (asc == 0x2c && ascq == 0x80) { - /* The scanner does have enough memory to scan the whole - * area. For instance the KV-SS25 has only 4MB of memory, - * which is not enough to scan a A4 page at 300dpi in gray - * 8 bits. */ - return SANE_STATUS_NO_MEM; - } - break; - - case 0x06: - if (asc == 0x29) { - /* Reset occured. May be the backend should retry the - * command. */ - return SANE_STATUS_GOOD; - } - break; + if (asc == 0x80) + { + /* Probably a paper jam. ascq might give more info. */ + return SANE_STATUS_JAMMED; } + break; - DBG(DBG_sense, "matsushita_sense_handler: unknown error condition. Please report it to the backend maintainer\n"); + case 0x05: + if (asc == 0x20 || asc == 0x24 || asc == 0x26) + { + /* Invalid command, invalid field in CDB or invalid field in data. + * The backend has prepared some wrong combination of options. + * Shot the backend maintainer. */ + return SANE_STATUS_IO_ERROR; + } + else if (asc == 0x2c && ascq == 0x80) + { + /* The scanner does have enough memory to scan the whole + * area. For instance the KV-SS25 has only 4MB of memory, + * which is not enough to scan a A4 page at 300dpi in gray + * 8 bits. */ + return SANE_STATUS_NO_MEM; + } + break; - return SANE_STATUS_IO_ERROR; + case 0x06: + if (asc == 0x29) + { + /* Reset occured. May be the backend should retry the + * command. */ + return SANE_STATUS_GOOD; + } + break; + } + + DBG (DBG_sense, + "matsushita_sense_handler: unknown error condition. Please report it to the backend maintainer\n"); + + return SANE_STATUS_IO_ERROR; } /* Check that a new page is available by issuing an empty read. The * sense handler might return SANE_STATUS_NO_DOCS which indicates that * the feeder is now empty. */ static SANE_Status -matsushita_check_next_page(Matsushita_Scanner *dev) +matsushita_check_next_page (Matsushita_Scanner * dev) { - CDB cdb; - SANE_Status status; + CDB cdb; + SANE_Status status; - DBG (DBG_proc, "matsushita_check_next_page: enter\n"); + DBG (DBG_proc, "matsushita_check_next_page: enter\n"); - MKSCSI_SCSI_READ_10 (cdb, 0, 0, 0); - cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */ - cdb.data[5] = dev->page_side; + MKSCSI_SCSI_READ_10 (cdb, 0, 0, 0); + cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */ + cdb.data[5] = dev->page_side; - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, NULL, NULL); + status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, NULL, NULL); - DBG (DBG_proc, "matsushita_check_next_page: exit with status %d\n", status); - - return (status); + DBG (DBG_proc, "matsushita_check_next_page: exit with status %d\n", status); + + return (status); } /* Attach a scanner to this backend. */ static SANE_Status attach_scanner (const char *devicename, Matsushita_Scanner ** devp) { - Matsushita_Scanner *dev; - int sfd; + Matsushita_Scanner *dev; + int sfd; - DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename); + DBG (DBG_sane_proc, "attach_scanner: %s\n", devicename); - if (devp) - *devp = NULL; + if (devp) + *devp = NULL; - /* Check if we know this device name. */ - for (dev = first_dev; dev; dev = dev->next) { - if (strcmp (dev->sane.name, devicename) == 0) { - if (devp) { - *devp = dev; - } - DBG (DBG_info, "device is already known\n"); - return SANE_STATUS_GOOD; - } + /* Check if we know this device name. */ + for (dev = first_dev; dev; dev = dev->next) + { + if (strcmp (dev->sane.name, devicename) == 0) + { + if (devp) + { + *devp = dev; + } + DBG (DBG_info, "device is already known\n"); + return SANE_STATUS_GOOD; } + } - /* Allocate a new scanner entry. */ - dev = matsushita_init (); - if (dev == NULL) { - DBG (DBG_error, "ERROR: not enough memory\n"); - return SANE_STATUS_NO_MEM; - } + /* Allocate a new scanner entry. */ + dev = matsushita_init (); + if (dev == NULL) + { + DBG (DBG_error, "ERROR: not enough memory\n"); + return SANE_STATUS_NO_MEM; + } - DBG (DBG_info, "attach_scanner: opening %s\n", devicename); + DBG (DBG_info, "attach_scanner: opening %s\n", devicename); - if (sanei_scsi_open (devicename, &sfd, matsushita_sense_handler, dev) != 0) { - DBG (DBG_error, "ERROR: attach_scanner: open failed\n"); - matsushita_free (dev); - return SANE_STATUS_INVAL; - } + if (sanei_scsi_open (devicename, &sfd, matsushita_sense_handler, dev) != 0) + { + DBG (DBG_error, "ERROR: attach_scanner: open failed\n"); + matsushita_free (dev); + return SANE_STATUS_INVAL; + } - /* Fill some scanner specific values. */ - dev->devicename = strdup (devicename); - dev->sfd = sfd; + /* Fill some scanner specific values. */ + dev->devicename = strdup (devicename); + dev->sfd = sfd; - /* Now, check that it is a scanner we support. */ - if (matsushita_identify_scanner (dev) == SANE_FALSE) { - DBG (DBG_error, - "ERROR: attach_scanner: scanner-identification failed\n"); - matsushita_free (dev); - return SANE_STATUS_INVAL; - } + /* Now, check that it is a scanner we support. */ + if (matsushita_identify_scanner (dev) == SANE_FALSE) + { + DBG (DBG_error, + "ERROR: attach_scanner: scanner-identification failed\n"); + matsushita_free (dev); + return SANE_STATUS_INVAL; + } - matsushita_close (dev); + matsushita_close (dev); - /* Set the default options for that scanner. */ - dev->sane.name = dev->devicename; - dev->sane.vendor = dev->scsi_vendor; - dev->sane.model = dev->scsi_product; - dev->sane.type = SANE_I18N ("sheetfed scanner"); + /* Set the default options for that scanner. */ + dev->sane.name = dev->devicename; + dev->sane.vendor = dev->scsi_vendor; + dev->sane.model = dev->scsi_product; + dev->sane.type = SANE_I18N ("sheetfed scanner"); - /* Link the scanner with the others. */ - dev->next = first_dev; - first_dev = dev; + /* Link the scanner with the others. */ + dev->next = first_dev; + first_dev = dev; - if (devp) { - *devp = dev; - } + if (devp) + { + *devp = dev; + } - num_devices++; + num_devices++; - DBG (DBG_proc, "attach_scanner: exit\n"); + DBG (DBG_proc, "attach_scanner: exit\n"); - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } static SANE_Status attach_one (const char *dev) { - attach_scanner (dev, NULL); - return SANE_STATUS_GOOD; + attach_scanner (dev, NULL); + return SANE_STATUS_GOOD; } /* Reset the options for that scanner. */ static void matsushita_init_options (Matsushita_Scanner * dev) { - int i; + int i; - /* Pre-initialize the options. */ - memset (dev->opt, 0, sizeof (dev->opt)); - memset (dev->val, 0, sizeof (dev->val)); + /* Pre-initialize the options. */ + memset (dev->opt, 0, sizeof (dev->opt)); + memset (dev->val, 0, sizeof (dev->val)); - for (i = 0; i < NUM_OPTIONS; ++i) { - dev->opt[i].size = sizeof (SANE_Word); - dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; - } + for (i = 0; i < NUM_OPTIONS; ++i) + { + dev->opt[i].size = sizeof (SANE_Word); + dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } - /* Number of options. */ - dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; - dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; - dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; - dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; - dev->val[OPT_NUM_OPTS].w = NUM_OPTIONS; + /* Number of options. */ + dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; + dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + dev->val[OPT_NUM_OPTS].w = NUM_OPTIONS; - /* Mode group */ - dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode"); - dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */ - dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; - dev->opt[OPT_MODE_GROUP].cap = 0; - dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + /* Mode group */ + dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode"); + dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_MODE_GROUP].cap = 0; + dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - /* Scanner supported modes */ - dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; - dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; - dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; - dev->opt[OPT_MODE].type = SANE_TYPE_STRING; - dev->opt[OPT_MODE].size = max_string_size(scanners[dev->scnum].scan_mode_list); - dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_MODE].constraint.string_list = scanners[dev->scnum].scan_mode_list; - dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */ + /* Scanner supported modes */ + dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; + dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + dev->opt[OPT_MODE].type = SANE_TYPE_STRING; + dev->opt[OPT_MODE].size = + max_string_size (scanners[dev->scnum].scan_mode_list); + dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_MODE].constraint.string_list = + scanners[dev->scnum].scan_mode_list; + dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */ - /* X and Y resolution */ - dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; - dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; - dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; - dev->opt[OPT_RESOLUTION].constraint.word_list = scanners[dev->scnum].resolutions_list; - dev->val[OPT_RESOLUTION].w = resolutions_list_300[1]; + /* X and Y resolution */ + dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; + dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; + dev->opt[OPT_RESOLUTION].constraint.word_list = + scanners[dev->scnum].resolutions_list; + dev->val[OPT_RESOLUTION].w = resolutions_list_300[1]; - /* Duplex */ - dev->opt[OPT_DUPLEX].name = SANE_NAME_DUPLEX; - dev->opt[OPT_DUPLEX].title = SANE_TITLE_DUPLEX; - dev->opt[OPT_DUPLEX].desc = SANE_DESC_DUPLEX; - dev->opt[OPT_DUPLEX].type = SANE_TYPE_BOOL; - dev->opt[OPT_DUPLEX].unit = SANE_UNIT_NONE; - dev->val[OPT_DUPLEX].w = SANE_FALSE; - if ((scanners[dev->scnum].cap & MAT_CAP_DUPLEX) == 0) - dev->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE; + /* Duplex */ + dev->opt[OPT_DUPLEX].name = SANE_NAME_DUPLEX; + dev->opt[OPT_DUPLEX].title = SANE_TITLE_DUPLEX; + dev->opt[OPT_DUPLEX].desc = SANE_DESC_DUPLEX; + dev->opt[OPT_DUPLEX].type = SANE_TYPE_BOOL; + dev->opt[OPT_DUPLEX].unit = SANE_UNIT_NONE; + dev->val[OPT_DUPLEX].w = SANE_FALSE; + if ((scanners[dev->scnum].cap & MAT_CAP_DUPLEX) == 0) + dev->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE; - /* Feeder mode */ - dev->opt[OPT_FEEDER_MODE].name = "feeder-mode"; - dev->opt[OPT_FEEDER_MODE].title = SANE_I18N("Feeder mode"); - dev->opt[OPT_FEEDER_MODE].desc = SANE_I18N("Sets the feeding mode"); - dev->opt[OPT_FEEDER_MODE].type = SANE_TYPE_STRING; - dev->opt[OPT_FEEDER_MODE].size = max_string_size(feeder_mode_list); - dev->opt[OPT_FEEDER_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_FEEDER_MODE].constraint.string_list = feeder_mode_list; - dev->val[OPT_FEEDER_MODE].s = strdup (feeder_mode_list[0]); + /* Feeder mode */ + dev->opt[OPT_FEEDER_MODE].name = "feeder-mode"; + dev->opt[OPT_FEEDER_MODE].title = SANE_I18N ("Feeder mode"); + dev->opt[OPT_FEEDER_MODE].desc = SANE_I18N ("Sets the feeding mode"); + dev->opt[OPT_FEEDER_MODE].type = SANE_TYPE_STRING; + dev->opt[OPT_FEEDER_MODE].size = max_string_size (feeder_mode_list); + dev->opt[OPT_FEEDER_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_FEEDER_MODE].constraint.string_list = feeder_mode_list; + dev->val[OPT_FEEDER_MODE].s = strdup (feeder_mode_list[0]); - /* Geometry group */ - dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); - dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */ - dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; - dev->opt[OPT_GEOMETRY_GROUP].cap = 0; - dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + /* Geometry group */ + dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); + dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_GEOMETRY_GROUP].cap = 0; + dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - /* Paper sizes list. */ - dev->opt[OPT_PAPER_SIZE].name = SANE_NAME_PAPER_SIZE; - dev->opt[OPT_PAPER_SIZE].title = SANE_TITLE_PAPER_SIZE; - dev->opt[OPT_PAPER_SIZE].desc = SANE_DESC_PAPER_SIZE; - dev->opt[OPT_PAPER_SIZE].type = SANE_TYPE_STRING; - dev->opt[OPT_PAPER_SIZE].size = max_string_size(dev->paper_sizes_list); - dev->opt[OPT_PAPER_SIZE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_PAPER_SIZE].constraint.string_list = dev->paper_sizes_list; - dev->val[OPT_PAPER_SIZE].s = strdup (""); /* will do it later */ + /* Paper sizes list. */ + dev->opt[OPT_PAPER_SIZE].name = SANE_NAME_PAPER_SIZE; + dev->opt[OPT_PAPER_SIZE].title = SANE_TITLE_PAPER_SIZE; + dev->opt[OPT_PAPER_SIZE].desc = SANE_DESC_PAPER_SIZE; + dev->opt[OPT_PAPER_SIZE].type = SANE_TYPE_STRING; + dev->opt[OPT_PAPER_SIZE].size = max_string_size (dev->paper_sizes_list); + dev->opt[OPT_PAPER_SIZE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_PAPER_SIZE].constraint.string_list = dev->paper_sizes_list; + dev->val[OPT_PAPER_SIZE].s = strdup (""); /* will do it later */ - /* Upper left X */ - dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; - dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; - dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; - dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED; - dev->opt[OPT_TL_X].unit = SANE_UNIT_MM; - dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_TL_X].constraint.range = &(scanners[dev->scnum].x_range); + /* Upper left X */ + dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; + dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; + dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; + dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED; + dev->opt[OPT_TL_X].unit = SANE_UNIT_MM; + dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_TL_X].constraint.range = &(scanners[dev->scnum].x_range); - /* Upper left Y */ - dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; - dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; - dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; - dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; - dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM; - dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_TL_Y].constraint.range = &(scanners[dev->scnum].y_range); + /* Upper left Y */ + dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; + dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; + dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; + dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; + dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_TL_Y].constraint.range = &(scanners[dev->scnum].y_range); - /* Bottom-right x */ - dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; - dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; - dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; - dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED; - dev->opt[OPT_BR_X].unit = SANE_UNIT_MM; - dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_BR_X].constraint.range = &(scanners[dev->scnum].x_range); + /* Bottom-right x */ + dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; + dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; + dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; + dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED; + dev->opt[OPT_BR_X].unit = SANE_UNIT_MM; + dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BR_X].constraint.range = &(scanners[dev->scnum].x_range); - /* Bottom-right y */ - dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; - dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; - dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; - dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; - dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM; - dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_BR_Y].constraint.range = &(scanners[dev->scnum].y_range); + /* Bottom-right y */ + dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; + dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; + dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; + dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; + dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BR_Y].constraint.range = &(scanners[dev->scnum].y_range); - /* Enhancement group */ - dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); - dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */ - dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; - dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; - dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; + /* Enhancement group */ + dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); + dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */ + dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; + dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; + dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; - /* Brightness */ - dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; - dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; - dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; - dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; - dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; - dev->opt[OPT_BRIGHTNESS].size = sizeof (SANE_Int); - dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_BRIGHTNESS].constraint.range = &(scanners[dev->scnum].brightness_range); - dev->val[OPT_BRIGHTNESS].w = 128; + /* Brightness */ + dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; + dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; + dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; + dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; + dev->opt[OPT_BRIGHTNESS].size = sizeof (SANE_Int); + dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BRIGHTNESS].constraint.range = + &(scanners[dev->scnum].brightness_range); + dev->val[OPT_BRIGHTNESS].w = 128; - /* Contrast */ - dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; - dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; - dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; - dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT; - dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; - dev->opt[OPT_CONTRAST].size = sizeof (SANE_Int); - dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_CONTRAST].constraint.range = &(scanners[dev->scnum].contrast_range); - dev->val[OPT_CONTRAST].w = 128; - if ((scanners[dev->scnum].cap & MAT_CAP_CONTRAST) == 0) - dev->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; + /* Contrast */ + dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; + dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; + dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; + dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT; + dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; + dev->opt[OPT_CONTRAST].size = sizeof (SANE_Int); + dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_CONTRAST].constraint.range = + &(scanners[dev->scnum].contrast_range); + dev->val[OPT_CONTRAST].w = 128; + if ((scanners[dev->scnum].cap & MAT_CAP_CONTRAST) == 0) + dev->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; - /* Automatic threshold */ - dev->opt[OPT_AUTOMATIC_THRESHOLD].name = "automatic-threshold"; - dev->opt[OPT_AUTOMATIC_THRESHOLD].title = SANE_I18N("Automatic threshold"); - dev->opt[OPT_AUTOMATIC_THRESHOLD].desc = SANE_I18N("Automatically sets brightness, contrast, white level, gamma, noise reduction and image emphasis"); - dev->opt[OPT_AUTOMATIC_THRESHOLD].type = SANE_TYPE_STRING; - dev->opt[OPT_AUTOMATIC_THRESHOLD].size = max_string_size(automatic_threshold_list); - dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint.string_list = automatic_threshold_list; - dev->val[OPT_AUTOMATIC_THRESHOLD].s = strdup (automatic_threshold_list[0]); - if ((scanners[dev->scnum].cap & MAT_CAP_AUTOMATIC_THRESHOLD) == 0) - dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE; + /* Automatic threshold */ + dev->opt[OPT_AUTOMATIC_THRESHOLD].name = "automatic-threshold"; + dev->opt[OPT_AUTOMATIC_THRESHOLD].title = SANE_I18N ("Automatic threshold"); + dev->opt[OPT_AUTOMATIC_THRESHOLD].desc = + SANE_I18N + ("Automatically sets brightness, contrast, white level, gamma, noise reduction and image emphasis"); + dev->opt[OPT_AUTOMATIC_THRESHOLD].type = SANE_TYPE_STRING; + dev->opt[OPT_AUTOMATIC_THRESHOLD].size = + max_string_size (automatic_threshold_list); + dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint_type = + SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint.string_list = + automatic_threshold_list; + dev->val[OPT_AUTOMATIC_THRESHOLD].s = strdup (automatic_threshold_list[0]); + if ((scanners[dev->scnum].cap & MAT_CAP_AUTOMATIC_THRESHOLD) == 0) + dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE; - /* Halftone pattern */ - dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN; - dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN; - dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN; - dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING; - dev->opt[OPT_HALFTONE_PATTERN].size = max_string_size(halftone_pattern_list); - dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list = halftone_pattern_list; - dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]); - - /* Automatic separation */ - dev->opt[OPT_AUTOMATIC_SEPARATION].name = SANE_NAME_AUTOSEP; - dev->opt[OPT_AUTOMATIC_SEPARATION].title = SANE_TITLE_AUTOSEP; - dev->opt[OPT_AUTOMATIC_SEPARATION].desc = SANE_DESC_AUTOSEP; - dev->opt[OPT_AUTOMATIC_SEPARATION].type = SANE_TYPE_BOOL; - dev->opt[OPT_AUTOMATIC_SEPARATION].unit = SANE_UNIT_NONE; - dev->val[OPT_AUTOMATIC_SEPARATION].w = SANE_FALSE; + /* Halftone pattern */ + dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN; + dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING; + dev->opt[OPT_HALFTONE_PATTERN].size = + max_string_size (halftone_pattern_list); + dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_HALFTONE_PATTERN].constraint_type = + SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list = + halftone_pattern_list; + dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]); - /* White level base */ - dev->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL; - dev->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL; - dev->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL; - dev->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_STRING; - dev->opt[OPT_WHITE_LEVEL].size = max_string_size(white_level_list); - dev->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_WHITE_LEVEL].constraint.string_list = white_level_list; - dev->val[OPT_WHITE_LEVEL].s = strdup (white_level_list[0]); - if ((scanners[dev->scnum].cap & MAT_CAP_WHITE_LEVEL) == 0) - dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE; + /* Automatic separation */ + dev->opt[OPT_AUTOMATIC_SEPARATION].name = SANE_NAME_AUTOSEP; + dev->opt[OPT_AUTOMATIC_SEPARATION].title = SANE_TITLE_AUTOSEP; + dev->opt[OPT_AUTOMATIC_SEPARATION].desc = SANE_DESC_AUTOSEP; + dev->opt[OPT_AUTOMATIC_SEPARATION].type = SANE_TYPE_BOOL; + dev->opt[OPT_AUTOMATIC_SEPARATION].unit = SANE_UNIT_NONE; + dev->val[OPT_AUTOMATIC_SEPARATION].w = SANE_FALSE; - /* Noise reduction */ - dev->opt[OPT_NOISE_REDUCTION].name = "noise-reduction"; - dev->opt[OPT_NOISE_REDUCTION].title = SANE_I18N("Noise reduction"); - dev->opt[OPT_NOISE_REDUCTION].desc = SANE_I18N("Reduce the isolated dot noise"); - dev->opt[OPT_NOISE_REDUCTION].type = SANE_TYPE_STRING; - dev->opt[OPT_NOISE_REDUCTION].size = max_string_size(noise_reduction_list); - dev->opt[OPT_NOISE_REDUCTION].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_NOISE_REDUCTION].constraint.string_list = noise_reduction_list; - dev->val[OPT_NOISE_REDUCTION].s = strdup (noise_reduction_list[0]); - if ((scanners[dev->scnum].cap & MAT_CAP_NOISE_REDUCTION) == 0) - dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE; + /* White level base */ + dev->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL; + dev->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL; + dev->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL; + dev->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_STRING; + dev->opt[OPT_WHITE_LEVEL].size = max_string_size (white_level_list); + dev->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_WHITE_LEVEL].constraint.string_list = white_level_list; + dev->val[OPT_WHITE_LEVEL].s = strdup (white_level_list[0]); + if ((scanners[dev->scnum].cap & MAT_CAP_WHITE_LEVEL) == 0) + dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE; - /* Image emphasis */ - dev->opt[OPT_IMAGE_EMPHASIS].name = "image-emphasis"; - dev->opt[OPT_IMAGE_EMPHASIS].title = SANE_I18N("Image emphasis"); - dev->opt[OPT_IMAGE_EMPHASIS].desc = SANE_I18N("Sets the image emphasis"); - dev->opt[OPT_IMAGE_EMPHASIS].type = SANE_TYPE_STRING; - dev->opt[OPT_IMAGE_EMPHASIS].size = max_string_size(scanners[dev->scnum].image_emphasis_list); - dev->opt[OPT_IMAGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_IMAGE_EMPHASIS].constraint.string_list = scanners[dev->scnum].image_emphasis_list; - dev->val[OPT_IMAGE_EMPHASIS].s = strdup(SANE_I18N("Medium")); + /* Noise reduction */ + dev->opt[OPT_NOISE_REDUCTION].name = "noise-reduction"; + dev->opt[OPT_NOISE_REDUCTION].title = SANE_I18N ("Noise reduction"); + dev->opt[OPT_NOISE_REDUCTION].desc = + SANE_I18N ("Reduce the isolated dot noise"); + dev->opt[OPT_NOISE_REDUCTION].type = SANE_TYPE_STRING; + dev->opt[OPT_NOISE_REDUCTION].size = max_string_size (noise_reduction_list); + dev->opt[OPT_NOISE_REDUCTION].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_NOISE_REDUCTION].constraint.string_list = noise_reduction_list; + dev->val[OPT_NOISE_REDUCTION].s = strdup (noise_reduction_list[0]); + if ((scanners[dev->scnum].cap & MAT_CAP_NOISE_REDUCTION) == 0) + dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE; - /* Gamma */ - dev->opt[OPT_GAMMA].name = "gamma"; - dev->opt[OPT_GAMMA].title = SANE_I18N("Gamma"); - dev->opt[OPT_GAMMA].desc = SANE_I18N("Gamma"); - dev->opt[OPT_GAMMA].type = SANE_TYPE_STRING; - dev->opt[OPT_GAMMA].size = max_string_size (gamma_list); - dev->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_GAMMA].constraint.string_list = gamma_list; - dev->val[OPT_GAMMA].s = strdup(gamma_list[0]); + /* Image emphasis */ + dev->opt[OPT_IMAGE_EMPHASIS].name = "image-emphasis"; + dev->opt[OPT_IMAGE_EMPHASIS].title = SANE_I18N ("Image emphasis"); + dev->opt[OPT_IMAGE_EMPHASIS].desc = SANE_I18N ("Sets the image emphasis"); + dev->opt[OPT_IMAGE_EMPHASIS].type = SANE_TYPE_STRING; + dev->opt[OPT_IMAGE_EMPHASIS].size = + max_string_size (scanners[dev->scnum].image_emphasis_list); + dev->opt[OPT_IMAGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_IMAGE_EMPHASIS].constraint.string_list = + scanners[dev->scnum].image_emphasis_list; + dev->val[OPT_IMAGE_EMPHASIS].s = strdup (SANE_I18N ("Medium")); - /* Lastly, set the default scan mode. This might change some - * values previously set here. */ - sane_control_option (dev, OPT_PAPER_SIZE, SANE_ACTION_SET_VALUE, - (SANE_String_Const *) dev->paper_sizes_list[0], - NULL); - sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE, - (SANE_String_Const *) scanners[dev->scnum].scan_mode_list[0], - NULL); + /* Gamma */ + dev->opt[OPT_GAMMA].name = "gamma"; + dev->opt[OPT_GAMMA].title = SANE_I18N ("Gamma"); + dev->opt[OPT_GAMMA].desc = SANE_I18N ("Gamma"); + dev->opt[OPT_GAMMA].type = SANE_TYPE_STRING; + dev->opt[OPT_GAMMA].size = max_string_size (gamma_list); + dev->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_GAMMA].constraint.string_list = gamma_list; + dev->val[OPT_GAMMA].s = strdup (gamma_list[0]); + + /* Lastly, set the default scan mode. This might change some + * values previously set here. */ + sane_control_option (dev, OPT_PAPER_SIZE, SANE_ACTION_SET_VALUE, + (SANE_String_Const *) dev->paper_sizes_list[0], NULL); + sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE, + (SANE_String_Const *) scanners[dev->scnum]. + scan_mode_list[0], NULL); } /* Wait until the scanner is ready. @@ -1192,196 +1255,213 @@ matsushita_init_options (Matsushita_Scanner * dev) static SANE_Status matsushita_wait_scanner (Matsushita_Scanner * dev) { - SANE_Status status; - int timeout; - CDB cdb; + SANE_Status status; + int timeout; + CDB cdb; - DBG (DBG_proc, "matsushita_wait_scanner: enter\n"); + DBG (DBG_proc, "matsushita_wait_scanner: enter\n"); - MKSCSI_SCSI_TEST_UNIT_READY (cdb); + MKSCSI_SCSI_TEST_UNIT_READY (cdb); - /* Set the timeout to 60 seconds. */ - timeout = 60; + /* Set the timeout to 60 seconds. */ + timeout = 60; - while (timeout > 0) { + while (timeout > 0) + { - /* test unit ready */ - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, NULL, NULL); + /* test unit ready */ + status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, NULL, NULL); - if (status == SANE_STATUS_GOOD) { - return SANE_STATUS_GOOD; - } + if (status == SANE_STATUS_GOOD) + { + return SANE_STATUS_GOOD; + } - sleep(1); - }; + sleep (1); + }; - DBG (DBG_proc, "matsushita_wait_scanner: scanner not ready\n"); - return (SANE_STATUS_IO_ERROR); + DBG (DBG_proc, "matsushita_wait_scanner: scanner not ready\n"); + return (SANE_STATUS_IO_ERROR); } /* Reset a window. This is used to re-initialize the scanner. */ static SANE_Status matsushita_reset_window (Matsushita_Scanner * dev) { - CDB cdb; - SANE_Status status; + CDB cdb; + SANE_Status status; - DBG (DBG_proc, "matsushita_reset_window: enter\n"); + DBG (DBG_proc, "matsushita_reset_window: enter\n"); - MKSCSI_SCSI_SET_WINDOW (cdb, 0); + MKSCSI_SCSI_SET_WINDOW (cdb, 0); - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, NULL, NULL); + status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, NULL, NULL); - DBG (DBG_proc, "matsushita_reset_window: exit, status=%d\n", status); + DBG (DBG_proc, "matsushita_reset_window: exit, status=%d\n", status); - return status; + return status; } /* Set a window. */ static SANE_Status matsushita_set_window (Matsushita_Scanner * dev, int side) { - size_t size; - CDB cdb; - struct - { /* this sucks a lot */ - char cdb[10]; - unsigned char window[72]; - } - param; - SANE_Status status; - int i; + size_t size; + CDB cdb; + struct + { /* this sucks a lot */ + char cdb[10]; + unsigned char window[72]; + } + param; + SANE_Status status; + int i; - DBG (DBG_proc, "matsushita_set_window: enter\n"); + DBG (DBG_proc, "matsushita_set_window: enter\n"); - size = sizeof (param.window); - MKSCSI_SCSI_SET_WINDOW (cdb, size); + size = sizeof (param.window); + MKSCSI_SCSI_SET_WINDOW (cdb, size); - memcpy (param.cdb, cdb.data, cdb.len); - memset (param.window, 0, size); + memcpy (param.cdb, cdb.data, cdb.len); + memset (param.window, 0, size); - /* size of the windows descriptor block */ - param.window[7] = 64; + /* size of the windows descriptor block */ + param.window[7] = 64; - /* Page side */ - param.window[8] = side; + /* Page side */ + param.window[8] = side; - /* X and Y resolution */ - Ito16 (dev->resolution, ¶m.window[10]); - Ito16 (dev->resolution, ¶m.window[12]); + /* X and Y resolution */ + Ito16 (dev->resolution, ¶m.window[10]); + Ito16 (dev->resolution, ¶m.window[12]); - /* Upper Left (X,Y) */ - Ito32 (dev->x_tl, ¶m.window[14]); - Ito32 (dev->y_tl, ¶m.window[18]); + /* Upper Left (X,Y) */ + Ito32 (dev->x_tl, ¶m.window[14]); + Ito32 (dev->y_tl, ¶m.window[18]); - /* Width and length */ - Ito32 (dev->width, ¶m.window[22]); - Ito32 (dev->length, ¶m.window[26]); - Ito32 (dev->width, ¶m.window[56]); /* again, verso? */ - Ito32 (dev->length, ¶m.window[60]); /* again, verso? */ + /* Width and length */ + Ito32 (dev->width, ¶m.window[22]); + Ito32 (dev->length, ¶m.window[26]); + Ito32 (dev->width, ¶m.window[56]); /* again, verso? */ + Ito32 (dev->length, ¶m.window[60]); /* again, verso? */ - /* Brightness */ - param.window[30] = 255 - dev->val[OPT_BRIGHTNESS].w; - param.window[31] = param.window[30]; /* same as brightness. */ + /* Brightness */ + param.window[30] = 255 - dev->val[OPT_BRIGHTNESS].w; + param.window[31] = param.window[30]; /* same as brightness. */ - /* Contrast */ - param.window[32] = dev->val[OPT_CONTRAST].w; + /* Contrast */ + param.window[32] = dev->val[OPT_CONTRAST].w; - /* Image Composition */ - switch(dev->scan_mode) { - case MATSUSHITA_BW: - param.window[33] = 0x00; - break; - case MATSUSHITA_HALFTONE: - param.window[33] = 0x01; - break; - case MATSUSHITA_GRAYSCALE: - param.window[33] = 0x02; - break; + /* Image Composition */ + switch (dev->scan_mode) + { + case MATSUSHITA_BW: + param.window[33] = 0x00; + break; + case MATSUSHITA_HALFTONE: + param.window[33] = 0x01; + break; + case MATSUSHITA_GRAYSCALE: + param.window[33] = 0x02; + break; + } + + /* Depth */ + param.window[34] = dev->depth; + + /* Gamma */ + if (dev->scan_mode == MATSUSHITA_GRAYSCALE) + { + i = get_string_list_index (gamma_list, dev->val[OPT_GAMMA].s); + param.window[52] = gamma_val[i]; + } + + /* Feeder mode */ + i = get_string_list_index (feeder_mode_list, dev->val[OPT_FEEDER_MODE].s); + param.window[65] = feeder_mode_val[i]; + + /* Image emphasis */ + i = + get_string_list_index (scanners[dev->scnum].image_emphasis_list, + dev->val[OPT_IMAGE_EMPHASIS].s); + param.window[51] = scanners[dev->scnum].image_emphasis_val[i]; + + /* White level */ + i = get_string_list_index (white_level_list, dev->val[OPT_WHITE_LEVEL].s); + param.window[68] = white_level_val[i]; + + /* Halftone pattern. */ + if (dev->scan_mode == MATSUSHITA_HALFTONE) + { + i = + get_string_list_index (halftone_pattern_list, + dev->val[OPT_HALFTONE_PATTERN].s); + param.window[36] = halftone_pattern_val[i]; + } + + if (dev->scan_mode == MATSUSHITA_BW || + dev->scan_mode == MATSUSHITA_HALFTONE) + { + + /* Noise reduction */ + i = + get_string_list_index (noise_reduction_list, + dev->val[OPT_NOISE_REDUCTION].s); + param.window[69] = noise_reduction_val[i]; + + /* Automatic separation */ + if (dev->val[OPT_AUTOMATIC_SEPARATION].w) + { + param.window[67] = 0x80; } - /* Depth */ - param.window[34] = dev->depth; + /* Automatic threshold. Must be last because it may override + * some previous options. */ + i = + get_string_list_index (automatic_threshold_list, + dev->val[OPT_AUTOMATIC_THRESHOLD].s); + param.window[66] = automatic_threshold_val[i]; - /* Gamma */ - if (dev->scan_mode == MATSUSHITA_GRAYSCALE) { - i = get_string_list_index(gamma_list, dev->val[OPT_GAMMA].s); - param.window[52] = gamma_val[i]; - } - - /* Feeder mode */ - i = get_string_list_index(feeder_mode_list, dev->val[OPT_FEEDER_MODE].s); - param.window[65] = feeder_mode_val[i]; - - /* Image emphasis */ - i = get_string_list_index(scanners[dev->scnum].image_emphasis_list, dev->val[OPT_IMAGE_EMPHASIS].s); - param.window[51] = scanners[dev->scnum].image_emphasis_val[i]; - - /* White level */ - i = get_string_list_index(white_level_list, dev->val[OPT_WHITE_LEVEL].s); - param.window[68] = white_level_val[i]; - - /* Halftone pattern. */ - if (dev->scan_mode == MATSUSHITA_HALFTONE) { - i = get_string_list_index(halftone_pattern_list, dev->val[OPT_HALFTONE_PATTERN].s); - param.window[36] = halftone_pattern_val[i]; + if (automatic_threshold_val[i] != 0) + { + /* Automatic threshold is enabled. */ + param.window[36] = 0; /* Halftone pattern. */ + param.window[51] = 0; /* Image emphasis */ + param.window[67] = 0; /* Automatic separation */ + param.window[68] = 0; /* White level */ + param.window[69] = 0; /* Noise reduction */ } + } - if (dev->scan_mode == MATSUSHITA_BW || - dev->scan_mode == MATSUSHITA_HALFTONE) { + hexdump (DBG_info2, "windows", param.window, 72); - /* Noise reduction */ - i = get_string_list_index(noise_reduction_list, dev->val[OPT_NOISE_REDUCTION].s); - param.window[69] = noise_reduction_val[i]; - - /* Automatic separation */ - if (dev->val[OPT_AUTOMATIC_SEPARATION].w) { - param.window[67] = 0x80; - } + status = sanei_scsi_cmd (dev->sfd, ¶m, sizeof (param), NULL, NULL); - /* Automatic threshold. Must be last because it may override - * some previous options. */ - i = get_string_list_index(automatic_threshold_list, dev->val[OPT_AUTOMATIC_THRESHOLD].s); - param.window[66] = automatic_threshold_val[i]; + DBG (DBG_proc, "matsushita_set_window: exit, status=%d\n", status); - if (automatic_threshold_val[i] != 0) { - /* Automatic threshold is enabled. */ - param.window[36] = 0;/* Halftone pattern. */ - param.window[51] = 0; /* Image emphasis */ - param.window[67] = 0; /* Automatic separation */ - param.window[68] = 0; /* White level */ - param.window[69] = 0; /* Noise reduction */ - } - } - - hexdump (DBG_info2, "windows", param.window, 72); - - status = sanei_scsi_cmd (dev->sfd, ¶m, sizeof (param), NULL, NULL); - - DBG (DBG_proc, "matsushita_set_window: exit, status=%d\n", status); - - return status; + return status; } /* Stop a scan. */ static SANE_Status do_cancel (Matsushita_Scanner * dev) { - DBG (DBG_sane_proc, "do_cancel enter\n"); + DBG (DBG_sane_proc, "do_cancel enter\n"); - if (dev->scanning == SANE_TRUE) { + if (dev->scanning == SANE_TRUE) + { - /* Reset the scanner */ - matsushita_reset_window(dev); + /* Reset the scanner */ + matsushita_reset_window (dev); - matsushita_close (dev); - } + matsushita_close (dev); + } - dev->scanning = SANE_FALSE; + dev->scanning = SANE_FALSE; - DBG (DBG_sane_proc, "do_cancel exit\n"); + DBG (DBG_sane_proc, "do_cancel exit\n"); - return SANE_STATUS_CANCELLED; + return SANE_STATUS_CANCELLED; } /*--------------------------------------------------------------------------*/ @@ -1391,780 +1471,870 @@ do_cancel (Matsushita_Scanner * dev) SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { - FILE *fp; - char dev_name[PATH_MAX]; - size_t len; + FILE *fp; + char dev_name[PATH_MAX]; + size_t len; - DBG_INIT (); + DBG_INIT (); - DBG (DBG_sane_init, "sane_init\n"); + DBG (DBG_sane_init, "sane_init\n"); - authorize = authorize; /* silence gcc */ + authorize = authorize; /* silence gcc */ - DBG (DBG_error, "This is sane-matsushita version %d.%d-%d\n", V_MAJOR, - V_MINOR, BUILD); - DBG (DBG_error, "(C) 2002 by Frank Zago\n"); + DBG (DBG_error, "This is sane-matsushita version %d.%d-%d\n", V_MAJOR, + V_MINOR, BUILD); + DBG (DBG_error, "(C) 2002 by Frank Zago\n"); - if (version_code) { - *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD); - } + if (version_code) + { + *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD); + } - fp = sanei_config_open (MATSUSHITA_CONFIG_FILE); - if (!fp) { - /* default to /dev/scanner instead of insisting on config file */ - attach_scanner ("/dev/scanner", 0); - return SANE_STATUS_GOOD; - } + fp = sanei_config_open (MATSUSHITA_CONFIG_FILE); + if (!fp) + { + /* default to /dev/scanner instead of insisting on config file */ + attach_scanner ("/dev/scanner", 0); + return SANE_STATUS_GOOD; + } - while (sanei_config_read (dev_name, sizeof (dev_name), fp)) { - if (dev_name[0] == '#') /* ignore line comments */ - continue; - len = strlen (dev_name); + while (sanei_config_read (dev_name, sizeof (dev_name), fp)) + { + if (dev_name[0] == '#') /* ignore line comments */ + continue; + len = strlen (dev_name); - if (!len) - continue; /* ignore empty lines */ + if (!len) + continue; /* ignore empty lines */ - sanei_config_attach_matching_devices (dev_name, attach_one); - } + sanei_config_attach_matching_devices (dev_name, attach_one); + } - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } SANE_Status sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) { - Matsushita_Scanner *dev; - int i; + Matsushita_Scanner *dev; + int i; - DBG (DBG_proc, "sane_get_devices: enter\n"); + DBG (DBG_proc, "sane_get_devices: enter\n"); - local_only = local_only; /* silence gcc */ + local_only = local_only; /* silence gcc */ - if (devlist) - free (devlist); + if (devlist) + free (devlist); - devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); - if (!devlist) - return SANE_STATUS_NO_MEM; + devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); + if (!devlist) + return SANE_STATUS_NO_MEM; - i = 0; - for (dev = first_dev; i < num_devices; dev = dev->next) - devlist[i++] = &dev->sane; - devlist[i++] = 0; + i = 0; + for (dev = first_dev; i < num_devices; dev = dev->next) + devlist[i++] = &dev->sane; + devlist[i++] = 0; - *device_list = devlist; + *device_list = devlist; - DBG (DBG_proc, "sane_get_devices: exit\n"); + DBG (DBG_proc, "sane_get_devices: exit\n"); - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } SANE_Status sane_open (SANE_String_Const devicename, SANE_Handle * handle) { - Matsushita_Scanner *dev; - SANE_Status status; + Matsushita_Scanner *dev; + SANE_Status status; - DBG (DBG_proc, "sane_open: enter\n"); + DBG (DBG_proc, "sane_open: enter\n"); - /* search for devicename */ - if (devicename[0]) { - DBG (DBG_info, "sane_open: devicename=%s\n", devicename); + /* search for devicename */ + if (devicename[0]) + { + DBG (DBG_info, "sane_open: devicename=%s\n", devicename); - for (dev = first_dev; dev; dev = dev->next) { - if (strcmp (dev->sane.name, devicename) == 0) { - break; - } - } - - if (!dev) { - status = attach_scanner (devicename, &dev); - if (status != SANE_STATUS_GOOD) { - return status; - } - } - } - else { - DBG (DBG_sane_info, - "sane_open: no devicename, opening first device\n"); - dev = first_dev; /* empty devicename -> use first device */ + for (dev = first_dev; dev; dev = dev->next) + { + if (strcmp (dev->sane.name, devicename) == 0) + { + break; + } } - if (!dev) { - DBG (DBG_error, "No scanner found\n"); - - return SANE_STATUS_INVAL; + if (!dev) + { + status = attach_scanner (devicename, &dev); + if (status != SANE_STATUS_GOOD) + { + return status; + } } + } + else + { + DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n"); + dev = first_dev; /* empty devicename -> use first device */ + } - /* Build a list a paper size that fit into this scanner. */ - matsushita_build_paper_sizes (dev); + if (!dev) + { + DBG (DBG_error, "No scanner found\n"); - matsushita_init_options (dev); + return SANE_STATUS_INVAL; + } - *handle = dev; + /* Build a list a paper size that fit into this scanner. */ + matsushita_build_paper_sizes (dev); - DBG (DBG_proc, "sane_open: exit\n"); + matsushita_init_options (dev); - return SANE_STATUS_GOOD; + *handle = dev; + + DBG (DBG_proc, "sane_open: exit\n"); + + return SANE_STATUS_GOOD; } const SANE_Option_Descriptor * sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) { - Matsushita_Scanner *dev = handle; + Matsushita_Scanner *dev = handle; - DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option); + DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option); - if ((unsigned) option >= NUM_OPTIONS) { - return NULL; - } + if ((unsigned) option >= NUM_OPTIONS) + { + return NULL; + } - DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); + DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); - return dev->opt + option; + return dev->opt + option; } SANE_Status sane_control_option (SANE_Handle handle, SANE_Int option, - SANE_Action action, void *val, SANE_Int * info) + SANE_Action action, void *val, SANE_Int * info) { - Matsushita_Scanner *dev = handle; - SANE_Status status; - SANE_Word cap; - SANE_String_Const name; - int i; - SANE_Word value; - int rc; + Matsushita_Scanner *dev = handle; + SANE_Status status; + SANE_Word cap; + SANE_String_Const name; + int i; + SANE_Word value; + int rc; - DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n", - option, action); + DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n", + option, action); - if (info) { - *info = 0; + if (info) + { + *info = 0; + } + + if (dev->scanning) + { + return SANE_STATUS_DEVICE_BUSY; + } + + if (option < 0 || option >= NUM_OPTIONS) + { + return SANE_STATUS_INVAL; + } + + cap = dev->opt[option].cap; + if (!SANE_OPTION_IS_ACTIVE (cap)) + { + return SANE_STATUS_INVAL; + } + + name = dev->opt[option].name; + if (!name) + { + name = "(no name)"; + } + if (action == SANE_ACTION_GET_VALUE) + { + + switch (option) + { + /* word options */ + case OPT_NUM_OPTS: + case OPT_RESOLUTION: + case OPT_TL_Y: + case OPT_BR_Y: + case OPT_TL_X: + case OPT_BR_X: + case OPT_BRIGHTNESS: + case OPT_CONTRAST: + case OPT_DUPLEX: + case OPT_AUTOMATIC_SEPARATION: + *(SANE_Word *) val = dev->val[option].w; + return SANE_STATUS_GOOD; + + /* string options */ + case OPT_MODE: + case OPT_FEEDER_MODE: + case OPT_HALFTONE_PATTERN: + case OPT_PAPER_SIZE: + case OPT_AUTOMATIC_THRESHOLD: + case OPT_WHITE_LEVEL: + case OPT_NOISE_REDUCTION: + case OPT_IMAGE_EMPHASIS: + case OPT_GAMMA: + strcpy (val, dev->val[option].s); + return SANE_STATUS_GOOD; + + default: + return SANE_STATUS_INVAL; + } + } + else if (action == SANE_ACTION_SET_VALUE) + { + + if (!SANE_OPTION_IS_SETTABLE (cap)) + { + DBG (DBG_error, "could not set option, not settable\n"); + return SANE_STATUS_INVAL; } - if (dev->scanning) { - return SANE_STATUS_DEVICE_BUSY; + status = sanei_constrain_value (dev->opt + option, val, info); + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "could not set option, invalid value\n"); + return status; } - if (option < 0 || option >= NUM_OPTIONS) { - return SANE_STATUS_INVAL; - } + switch (option) + { - cap = dev->opt[option].cap; - if (!SANE_OPTION_IS_ACTIVE (cap)) { - return SANE_STATUS_INVAL; - } + /* Side-effect options */ + case OPT_TL_Y: + case OPT_BR_Y: + DBG (DBG_info, "sane_get_option PREVINFO %f \n", + SANE_UNFIX (*(SANE_Word *) val)); - name = dev->opt[option].name; - if (!name) { - name = "(no name)"; - } - if (action == SANE_ACTION_GET_VALUE) { - switch (option) { - /* word options */ - case OPT_NUM_OPTS: - case OPT_RESOLUTION: - case OPT_TL_Y: - case OPT_BR_Y: - case OPT_TL_X: - case OPT_BR_X: - case OPT_BRIGHTNESS: - case OPT_CONTRAST: - case OPT_DUPLEX: - case OPT_AUTOMATIC_SEPARATION: - *(SANE_Word *) val = dev->val[option].w; - return SANE_STATUS_GOOD; + case OPT_RESOLUTION: + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + dev->val[option].w = *(SANE_Word *) val; + return SANE_STATUS_GOOD; - /* string options */ - case OPT_MODE: - case OPT_FEEDER_MODE: - case OPT_HALFTONE_PATTERN: - case OPT_PAPER_SIZE: - case OPT_AUTOMATIC_THRESHOLD: - case OPT_WHITE_LEVEL: - case OPT_NOISE_REDUCTION: - case OPT_IMAGE_EMPHASIS: - case OPT_GAMMA: - strcpy (val, dev->val[option].s); - return SANE_STATUS_GOOD; + /* The length of X must be rounded (up). */ + case OPT_TL_X: + case OPT_BR_X: - default: - return SANE_STATUS_INVAL; + value = mmToIlu (SANE_UNFIX (*(SANE_Word *) val)); + + i = get_int_list_index (scanners[dev->scnum].resolutions_list, + dev->val[OPT_RESOLUTION].w); + + if (value & (scanners[dev->scnum].resolutions_round[i] - 1)) + { + value = + (value | (scanners[dev->scnum].resolutions_round[i] - 1)) + 1; + if (info) + { + *info |= SANE_INFO_INEXACT; } + } + + *(SANE_Word *) val = SANE_FIX (iluToMm (value)); + + dev->val[option].w = *(SANE_Word *) val; + + if (info) + { + *info |= SANE_INFO_RELOAD_PARAMS; + } + + return SANE_STATUS_GOOD; + + /* Side-effect free options */ + case OPT_CONTRAST: + case OPT_BRIGHTNESS: + case OPT_DUPLEX: + case OPT_AUTOMATIC_SEPARATION: + dev->val[option].w = *(SANE_Word *) val; + return SANE_STATUS_GOOD; + + /* String mode */ + case OPT_HALFTONE_PATTERN: + case OPT_WHITE_LEVEL: + case OPT_NOISE_REDUCTION: + case OPT_IMAGE_EMPHASIS: + case OPT_GAMMA: + case OPT_FEEDER_MODE: + free (dev->val[option].s); + dev->val[option].s = (SANE_String) strdup (val); + return SANE_STATUS_GOOD; + + case OPT_MODE: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + + free (dev->val[OPT_MODE].s); + dev->val[OPT_MODE].s = (SANE_Char *) strdup (val); + + /* Set default options for the scan modes. */ + dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE; + + if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0) + { + dev->scan_mode = MATSUSHITA_BW; + dev->depth = 1; + + dev->opt[OPT_AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE; + } + else if (strcmp (dev->val[OPT_MODE].s, HALFTONE_STR) == 0) + { + dev->scan_mode = MATSUSHITA_HALFTONE; + dev->depth = 1; + + dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE; + } + else if (strcmp (dev->val[OPT_MODE].s, GRAY4_STR) == 0) + { + dev->scan_mode = MATSUSHITA_GRAYSCALE; + dev->depth = 4; + + dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE; + } + else if (strcmp (dev->val[OPT_MODE].s, GRAY8_STR) == 0) + { + dev->scan_mode = MATSUSHITA_GRAYSCALE; + dev->depth = 8; + + dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE; + } + else + { + assert (0 == 1); + } + + /* Some options might not be supported by the scanner. */ + if ((scanners[dev->scnum].cap & MAT_CAP_GAMMA) == 0) + dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE; + + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + } + return SANE_STATUS_GOOD; + + case OPT_PAPER_SIZE: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + + free (dev->val[OPT_PAPER_SIZE].s); + dev->val[OPT_PAPER_SIZE].s = (SANE_Char *) strdup (val); + + i = + get_string_list_index (dev->paper_sizes_list, + dev->val[OPT_PAPER_SIZE].s); + i = dev->paper_sizes_val[i]; + + /* Set the 4 corners values. */ + value = 0; + rc = sane_control_option (handle, OPT_TL_X, SANE_ACTION_SET_VALUE, + &value, info); + assert (rc == SANE_STATUS_GOOD); + + value = 0; + rc = sane_control_option (handle, OPT_TL_Y, SANE_ACTION_SET_VALUE, + &value, info); + assert (rc == SANE_STATUS_GOOD); + + value = SANE_FIX (paper_sizes[i].width); + rc = sane_control_option (handle, OPT_BR_X, SANE_ACTION_SET_VALUE, + &value, info); + assert (rc == SANE_STATUS_GOOD); + + value = SANE_FIX (paper_sizes[i].length); + rc = sane_control_option (handle, OPT_BR_Y, SANE_ACTION_SET_VALUE, + &value, info); + assert (rc == SANE_STATUS_GOOD); + + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + + return SANE_STATUS_GOOD; + + case OPT_AUTOMATIC_THRESHOLD: + if (strcmp (dev->val[option].s, val) == 0) + return SANE_STATUS_GOOD; + + free (dev->val[option].s); + dev->val[option].s = (SANE_Char *) strdup (val); + + /* If the threshold is not set to none, some option must + * disappear. */ + dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_IMAGE_EMPHASIS].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE; + dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; + + if (strcmp (dev->val[option].s, automatic_threshold_list[0]) == 0) + { + dev->opt[OPT_WHITE_LEVEL].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_IMAGE_EMPHASIS].cap &= ~SANE_CAP_INACTIVE; + dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; + if (dev->scan_mode == MATSUSHITA_HALFTONE) + { + dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; + } + } + + if (info) + { + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + } + return SANE_STATUS_GOOD; + + default: + return SANE_STATUS_INVAL; } - else if (action == SANE_ACTION_SET_VALUE) { + } - if (!SANE_OPTION_IS_SETTABLE (cap)) { - DBG (DBG_error, "could not set option, not settable\n"); - return SANE_STATUS_INVAL; - } + DBG (DBG_proc, "sane_control_option: exit, bad\n"); - status = sanei_constrain_value (dev->opt + option, val, info); - if (status != SANE_STATUS_GOOD) { - DBG (DBG_error, "could not set option, invalid value\n"); - return status; - } - - switch (option) { - - /* Side-effect options */ - case OPT_TL_Y: - case OPT_BR_Y: - DBG (DBG_info, "sane_get_option PREVINFO %f \n", - SANE_UNFIX(*(SANE_Word *) val)); - - - case OPT_RESOLUTION: - if (info) { - *info |= SANE_INFO_RELOAD_PARAMS; - } - dev->val[option].w = *(SANE_Word *) val; - return SANE_STATUS_GOOD; - - /* The length of X must be rounded (up). */ - case OPT_TL_X: - case OPT_BR_X: - - value = mmToIlu (SANE_UNFIX (*(SANE_Word *) val)); - - i = get_int_list_index(scanners[dev->scnum].resolutions_list, - dev->val[OPT_RESOLUTION].w); - - if (value & (scanners[dev->scnum].resolutions_round[i]-1)) { - value = (value | (scanners[dev->scnum].resolutions_round[i]-1)) + 1; - if (info) { - *info |= SANE_INFO_INEXACT; - } - } - - *(SANE_Word *) val = SANE_FIX (iluToMm (value)); - - dev->val[option].w = *(SANE_Word *) val; - - if (info) { - *info |= SANE_INFO_RELOAD_PARAMS; - } - - return SANE_STATUS_GOOD; - - /* Side-effect free options */ - case OPT_CONTRAST: - case OPT_BRIGHTNESS: - case OPT_DUPLEX: - case OPT_AUTOMATIC_SEPARATION: - dev->val[option].w = *(SANE_Word *) val; - return SANE_STATUS_GOOD; - - /* String mode */ - case OPT_HALFTONE_PATTERN: - case OPT_WHITE_LEVEL: - case OPT_NOISE_REDUCTION: - case OPT_IMAGE_EMPHASIS: - case OPT_GAMMA: - case OPT_FEEDER_MODE: - free (dev->val[option].s); - dev->val[option].s = (SANE_String) strdup (val); - return SANE_STATUS_GOOD; - - case OPT_MODE: - if (strcmp(dev->val[option].s, val) == 0) - return SANE_STATUS_GOOD; - - free (dev->val[OPT_MODE].s); - dev->val[OPT_MODE].s = (SANE_Char *) strdup (val); - - /* Set default options for the scan modes. */ - dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE; - - if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0) { - dev->scan_mode = MATSUSHITA_BW; - dev->depth = 1; - - dev->opt[OPT_AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE; - } - else if (strcmp (dev->val[OPT_MODE].s, HALFTONE_STR) == 0) { - dev->scan_mode = MATSUSHITA_HALFTONE; - dev->depth = 1; - - dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE; - } - else if (strcmp (dev->val[OPT_MODE].s, GRAY4_STR) == 0) { - dev->scan_mode = MATSUSHITA_GRAYSCALE; - dev->depth = 4; - - dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE; - } - else if (strcmp (dev->val[OPT_MODE].s, GRAY8_STR) == 0) { - dev->scan_mode = MATSUSHITA_GRAYSCALE; - dev->depth = 8; - - dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE; - } else { - assert(0==1); - } - - /* Some options might not be supported by the scanner. */ - if ((scanners[dev->scnum].cap & MAT_CAP_GAMMA) == 0) - dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE; - - if (info) { - *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; - } - return SANE_STATUS_GOOD; - - case OPT_PAPER_SIZE: - if (strcmp(dev->val[option].s, val) == 0) - return SANE_STATUS_GOOD; - - free (dev->val[OPT_PAPER_SIZE].s); - dev->val[OPT_PAPER_SIZE].s = (SANE_Char *) strdup (val); - - i = get_string_list_index(dev->paper_sizes_list, dev->val[OPT_PAPER_SIZE].s); - i = dev->paper_sizes_val[i]; - - /* Set the 4 corners values. */ - value = 0; - rc = sane_control_option (handle, OPT_TL_X, SANE_ACTION_SET_VALUE, - &value, info); - assert(rc == SANE_STATUS_GOOD); - - value = 0; - rc = sane_control_option (handle, OPT_TL_Y, SANE_ACTION_SET_VALUE, - &value, info); - assert(rc == SANE_STATUS_GOOD); - - value = SANE_FIX(paper_sizes[i].width); - rc = sane_control_option (handle, OPT_BR_X, SANE_ACTION_SET_VALUE, - &value, info); - assert(rc == SANE_STATUS_GOOD); - - value = SANE_FIX(paper_sizes[i].length); - rc = sane_control_option (handle, OPT_BR_Y, SANE_ACTION_SET_VALUE, - &value, info); - assert(rc == SANE_STATUS_GOOD); - - if (info) - *info |= SANE_INFO_RELOAD_OPTIONS; - - return SANE_STATUS_GOOD; - - case OPT_AUTOMATIC_THRESHOLD: - if (strcmp(dev->val[option].s, val) == 0) - return SANE_STATUS_GOOD; - - free (dev->val[option].s); - dev->val[option].s = (SANE_Char *) strdup (val); - - /* If the threshold is not set to none, some option must - * disappear. */ - dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_IMAGE_EMPHASIS].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE; - dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; - - if (strcmp(dev->val[option].s, automatic_threshold_list[0]) == 0) { - dev->opt[OPT_WHITE_LEVEL].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_IMAGE_EMPHASIS].cap &= ~SANE_CAP_INACTIVE; - dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE; - if (dev->scan_mode == MATSUSHITA_HALFTONE) { - dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; - } - } - - if (info) { - *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; - } - return SANE_STATUS_GOOD; - - default: - return SANE_STATUS_INVAL; - } - } - - DBG (DBG_proc, "sane_control_option: exit, bad\n"); - - return SANE_STATUS_UNSUPPORTED; + return SANE_STATUS_UNSUPPORTED; } SANE_Status sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) { - Matsushita_Scanner *dev = handle; + Matsushita_Scanner *dev = handle; - DBG (DBG_proc, "sane_get_parameters: enter\n"); + DBG (DBG_proc, "sane_get_parameters: enter\n"); - if (!(dev->scanning)) { + if (!(dev->scanning)) + { - /* Setup the parameters for the scan. These values will be re-used - * in the SET WINDOWS command. */ - dev->resolution = dev->val[OPT_RESOLUTION].w; + /* Setup the parameters for the scan. These values will be re-used + * in the SET WINDOWS command. */ + dev->resolution = dev->val[OPT_RESOLUTION].w; - dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)); - dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w)); - dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)); - dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w)); + dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)); + dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w)); + dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)); + dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w)); - /* Check the corners are OK. */ - if (dev->x_tl > dev->x_br) { - int s; - s = dev->x_tl; - dev->x_tl = dev->x_br; - dev->x_br = s; - } - if (dev->y_tl > dev->y_br) { - int s; - s = dev->y_tl; - dev->y_tl = dev->y_br; - dev->y_br = s; - } - - dev->width = dev->x_br - dev->x_tl; - dev->length = dev->y_br - dev->y_tl; - - /* Prepare the parameters for the caller. */ - memset (&dev->params, 0, sizeof (SANE_Parameters)); - - dev->params.format = SANE_FRAME_GRAY; - dev->params.last_frame = SANE_TRUE; - dev->params.pixels_per_line = (((dev->width * dev->resolution) / 1200) + 7) & ~0x7; - - if (dev->depth == 4) { - dev->params.depth = 8; - } else { - dev->params.depth = dev->depth; - } - dev->params.bytes_per_line = (dev->params.pixels_per_line / 8) * dev->params.depth; - dev->params.lines = (dev->length * dev->resolution) / 1200; + /* Check the corners are OK. */ + if (dev->x_tl > dev->x_br) + { + int s; + s = dev->x_tl; + dev->x_tl = dev->x_br; + dev->x_br = s; + } + if (dev->y_tl > dev->y_br) + { + int s; + s = dev->y_tl; + dev->y_tl = dev->y_br; + dev->y_br = s; } - /* Return the current values. */ - if (params) { - *params = (dev->params); - } - - DBG (DBG_proc, "sane_get_parameters: exit\n"); + dev->width = dev->x_br - dev->x_tl; + dev->length = dev->y_br - dev->y_tl; - return SANE_STATUS_GOOD; + /* Prepare the parameters for the caller. */ + memset (&dev->params, 0, sizeof (SANE_Parameters)); + + dev->params.format = SANE_FRAME_GRAY; + dev->params.last_frame = SANE_TRUE; + dev->params.pixels_per_line = + (((dev->width * dev->resolution) / 1200) + 7) & ~0x7; + + if (dev->depth == 4) + { + dev->params.depth = 8; + } + else + { + dev->params.depth = dev->depth; + } + dev->params.bytes_per_line = + (dev->params.pixels_per_line / 8) * dev->params.depth; + dev->params.lines = (dev->length * dev->resolution) / 1200; + } + + /* Return the current values. */ + if (params) + { + *params = (dev->params); + } + + DBG (DBG_proc, "sane_get_parameters: exit\n"); + + return SANE_STATUS_GOOD; } SANE_Status sane_start (SANE_Handle handle) { - Matsushita_Scanner *dev = handle; - SANE_Status status; + Matsushita_Scanner *dev = handle; + SANE_Status status; - DBG (DBG_proc, "sane_start: enter\n"); + DBG (DBG_proc, "sane_start: enter\n"); - if (!(dev->scanning)) { + if (!(dev->scanning)) + { - sane_get_parameters (dev, NULL); + sane_get_parameters (dev, NULL); - if (dev->image == NULL) { - dev->image_size = 3 * dev->buffer_size; - dev->image = malloc (dev->image_size); - if (dev->image == NULL) { - return SANE_STATUS_NO_MEM; - } - } - - /* Open again the scanner. */ - if (sanei_scsi_open - (dev->devicename, &(dev->sfd), matsushita_sense_handler, dev) != 0) { - DBG (DBG_error, "ERROR: sane_start: open failed\n"); - return SANE_STATUS_INVAL; - } - - dev->page_side = 0; /* page front */ - dev->page_num = 0; /* first page */ - - /* The scanner must be ready. */ - status = matsushita_wait_scanner (dev); - if (status) { - matsushita_close (dev); - return status; - } - - status = matsushita_reset_window (dev); - if (status) { - matsushita_close (dev); - return status; - } - - status = matsushita_set_window (dev, PAGE_FRONT); - if (status) { - matsushita_close (dev); - return status; - } - - if (dev->val[OPT_DUPLEX].w == SANE_TRUE) { - status = matsushita_set_window (dev, PAGE_BACK); - if (status) { - matsushita_close (dev); - return status; - } - } - - status = matsushita_read_document_size (dev); - if (status) { - matsushita_close (dev); - return status; - } - - } else { - if (dev->val[OPT_DUPLEX].w == SANE_TRUE && - dev->page_side == PAGE_FRONT) { - dev->page_side = PAGE_BACK; - } else { - /* new sheet. */ - dev->page_side = PAGE_FRONT; - dev->page_num++; - } - - status = matsushita_check_next_page(dev); - if (status) { - return status; - } + if (dev->image == NULL) + { + dev->image_size = 3 * dev->buffer_size; + dev->image = malloc (dev->image_size); + if (dev->image == NULL) + { + return SANE_STATUS_NO_MEM; + } } - dev->bytes_left = dev->params.bytes_per_line * dev->params.lines; - dev->image_end = 0; - dev->image_begin = 0; + /* Open again the scanner. */ + if (sanei_scsi_open + (dev->devicename, &(dev->sfd), matsushita_sense_handler, dev) != 0) + { + DBG (DBG_error, "ERROR: sane_start: open failed\n"); + return SANE_STATUS_INVAL; + } - dev->scanning = SANE_TRUE; + dev->page_side = 0; /* page front */ + dev->page_num = 0; /* first page */ - DBG (DBG_proc, "sane_start: exit\n"); + /* The scanner must be ready. */ + status = matsushita_wait_scanner (dev); + if (status) + { + matsushita_close (dev); + return status; + } - return SANE_STATUS_GOOD; + status = matsushita_reset_window (dev); + if (status) + { + matsushita_close (dev); + return status; + } + + status = matsushita_set_window (dev, PAGE_FRONT); + if (status) + { + matsushita_close (dev); + return status; + } + + if (dev->val[OPT_DUPLEX].w == SANE_TRUE) + { + status = matsushita_set_window (dev, PAGE_BACK); + if (status) + { + matsushita_close (dev); + return status; + } + } + + status = matsushita_read_document_size (dev); + if (status) + { + matsushita_close (dev); + return status; + } + + } + else + { + if (dev->val[OPT_DUPLEX].w == SANE_TRUE && dev->page_side == PAGE_FRONT) + { + dev->page_side = PAGE_BACK; + } + else + { + /* new sheet. */ + dev->page_side = PAGE_FRONT; + dev->page_num++; + } + + status = matsushita_check_next_page (dev); + if (status) + { + return status; + } + } + + dev->bytes_left = dev->params.bytes_per_line * dev->params.lines; + dev->image_end = 0; + dev->image_begin = 0; + + dev->scanning = SANE_TRUE; + + DBG (DBG_proc, "sane_start: exit\n"); + + return SANE_STATUS_GOOD; } SANE_Status sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, - SANE_Int * len) + SANE_Int * len) { - SANE_Status status; - Matsushita_Scanner *dev = handle; - size_t size; - CDB cdb; + SANE_Status status; + Matsushita_Scanner *dev = handle; + size_t size; + CDB cdb; - DBG (DBG_proc, "sane_read: enter\n"); + DBG (DBG_proc, "sane_read: enter\n"); - *len = 0; + *len = 0; - if (!(dev->scanning)) { - /* OOPS, not scanning */ - return do_cancel (dev); - } - - if (dev->depth == 4) { - size = dev->image_end - dev->image_begin; - if (size > 0) { - goto copy_4bits_buffer; - } + if (!(dev->scanning)) + { + /* OOPS, not scanning */ + return do_cancel (dev); } - /* - * Try to read the maximum number of bytes. - * - * The windows driver reads no more than 0x8000 byte. This backend - * operates differently than the windows driver. The windows TWAIN - * driver always read 2 more bytes at the end, so it gets a CHECK - * CONDITION with a short read sense. Since the linux scsi layer - * seem to be buggy regarding the resid, always read exactly the - * number of remaining bytes. - */ - size = dev->bytes_left; - if (size > (size_t)max_len) - size = max_len; + if (dev->depth == 4) + { + size = dev->image_end - dev->image_begin; + if (size > 0) + { + goto copy_4bits_buffer; + } + } - /* When depth is 4, the backend read 1 byte, but returns 2. */ - if (dev->depth == 4) { - size /= 2; + /* + * Try to read the maximum number of bytes. + * + * The windows driver reads no more than 0x8000 byte. This backend + * operates differently than the windows driver. The windows TWAIN + * driver always read 2 more bytes at the end, so it gets a CHECK + * CONDITION with a short read sense. Since the linux scsi layer + * seem to be buggy regarding the resid, always read exactly the + * number of remaining bytes. + */ + size = dev->bytes_left; + if (size > (size_t) max_len) + size = max_len; + + /* When depth is 4, the backend read 1 byte, but returns 2. */ + if (dev->depth == 4) + { + size /= 2; + } + + if (size > dev->buffer_size) + size = dev->buffer_size; + if (size > 0x8000) + size = 0x8000; + + DBG (DBG_info, "sane_read: to read = %ld bytes (bpl=%d)\n", + (long) size, dev->params.bytes_per_line); + + MKSCSI_SCSI_READ_10 (cdb, 0, 0, size); + cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */ + cdb.data[5] = dev->page_side; + + hexdump (DBG_info2, "sane_read: READ_10 CDB", cdb.data, 10); + + if (dev->depth == 4) + { + status = + sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); + } + else + { + status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, buf, &size); + } + + if (status == SANE_STATUS_EOF) + { + DBG (DBG_proc, "sane_read: exit, end of page scan\n"); + return (SANE_STATUS_EOF); + } + + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "sane_read: cannot read from the scanner\n"); + return status; + } + + if (dev->depth == 1) + { + /* For Black & White, the bits in every bytes are mirrored. + * for instance 11010001 is coded as 10001011 */ + + size_t i; + unsigned char c; + + for (i = 0; i < size; i++) + { + c = 0; + if (buf[i] & 0x01) + c |= 0x80; + if (buf[i] & 0x02) + c |= 0x40; + if (buf[i] & 0x04) + c |= 0x20; + if (buf[i] & 0x08) + c |= 0x10; + if (buf[i] & 0x10) + c |= 0x08; + if (buf[i] & 0x20) + c |= 0x04; + if (buf[i] & 0x40) + c |= 0x02; + if (buf[i] & 0x80) + c |= 0x01; + buf[i] = c; + } + } + else if (dev->depth == 4) + { + /* Adjust from a depth of 4 bits ([0..15]) to + * a depth of 8 bits ([0..255]) */ + + size_t i; + unsigned char *src = dev->buffer; + unsigned char *dest = dev->image; + + for (i = 0; i < size; i++) + { + *dest = ((*src & 0x0f) >> 0) * 17; + dest++; + *dest = ((*src & 0xf0) >> 4) * 17; + dest++; + src++; } - if (size > dev->buffer_size) - size = dev->buffer_size; - if (size > 0x8000) - size = 0x8000; + size *= 2; - DBG (DBG_info, "sane_read: to read = %ld bytes (bpl=%d)\n", - (long) size, dev->params.bytes_per_line); + dev->image_begin = 0; + dev->image_end = size; - MKSCSI_SCSI_READ_10 (cdb, 0, 0, size); - cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */ - cdb.data[5] = dev->page_side; + copy_4bits_buffer: - hexdump (DBG_info2, "sane_read: READ_10 CDB", cdb.data, 10); + if (size) + { + /* Still got some data. Send it. */ + if (size > (size_t) max_len) + size = max_len; + if (size > (size_t) dev->bytes_left) + size = dev->bytes_left; - if (dev->depth == 4) { - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, dev->buffer, &size); - } else { - status = sanei_scsi_cmd (dev->sfd, cdb.data, cdb.len, buf, &size); + memcpy (buf, dev->image + dev->image_begin, size); + dev->image_begin += size; } + } - if (status == SANE_STATUS_EOF) { - DBG (DBG_proc, "sane_read: exit, end of page scan\n"); - return (SANE_STATUS_EOF); - } - - if (status != SANE_STATUS_GOOD) { - DBG (DBG_error, "sane_read: cannot read from the scanner\n"); - return status; - } + dev->bytes_left -= size; + *len = size; - if (dev->depth == 1) { - /* For Black & White, the bits in every bytes are mirrored. - * for instance 11010001 is coded as 10001011 */ + DBG (DBG_info, "bytes_left=%d\n", dev->bytes_left); - size_t i; - unsigned char c; - - for (i=0; idepth == 4) { - /* Adjust from a depth of 4 bits ([0..15]) to - * a depth of 8 bits ([0..255]) */ - - size_t i; - unsigned char *src = dev->buffer; - unsigned char *dest = dev->image; - - for (i=0; i> 0) * 17; - dest++; - *dest = ((*src & 0xf0) >> 4) * 17; - dest++; - src++; - } - - size *= 2; - - dev->image_begin = 0; - dev->image_end = size; - - copy_4bits_buffer: - - if (size) { - /* Still got some data. Send it. */ - if (size > (size_t) max_len) - size = max_len; - if (size > (size_t) dev->bytes_left) - size = dev->bytes_left; - - memcpy (buf, dev->image + dev->image_begin, size); - dev->image_begin += size; - } - } - - dev->bytes_left -= size; - *len = size; - - DBG (DBG_info, "bytes_left=%d\n", dev->bytes_left); - - return SANE_STATUS_GOOD; + return SANE_STATUS_GOOD; } SANE_Status sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) { - DBG (DBG_proc, "sane_set_io_mode: enter\n"); + DBG (DBG_proc, "sane_set_io_mode: enter\n"); - handle = handle; /* silence gcc */ - non_blocking = non_blocking; /* silence gcc */ + handle = handle; /* silence gcc */ + non_blocking = non_blocking; /* silence gcc */ - DBG (DBG_proc, "sane_set_io_mode: exit\n"); + DBG (DBG_proc, "sane_set_io_mode: exit\n"); - return SANE_STATUS_UNSUPPORTED; + return SANE_STATUS_UNSUPPORTED; } SANE_Status sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) { - DBG (DBG_proc, "sane_get_select_fd: enter\n"); + DBG (DBG_proc, "sane_get_select_fd: enter\n"); - handle = handle; /* silence gcc */ - fd = fd; /* silence gcc */ + handle = handle; /* silence gcc */ + fd = fd; /* silence gcc */ - DBG (DBG_proc, "sane_get_select_fd: exit\n"); + DBG (DBG_proc, "sane_get_select_fd: exit\n"); - return SANE_STATUS_UNSUPPORTED; + return SANE_STATUS_UNSUPPORTED; } void sane_cancel (SANE_Handle handle) { - Matsushita_Scanner *dev = handle; + Matsushita_Scanner *dev = handle; - DBG (DBG_proc, "sane_cancel: enter\n"); + DBG (DBG_proc, "sane_cancel: enter\n"); - do_cancel (dev); + do_cancel (dev); - DBG (DBG_proc, "sane_cancel: exit\n"); + DBG (DBG_proc, "sane_cancel: exit\n"); } void sane_close (SANE_Handle handle) { - Matsushita_Scanner *dev = handle; - Matsushita_Scanner *dev_tmp; + Matsushita_Scanner *dev = handle; + Matsushita_Scanner *dev_tmp; - DBG (DBG_proc, "sane_close: enter\n"); + DBG (DBG_proc, "sane_close: enter\n"); - do_cancel (dev); - matsushita_close (dev); + do_cancel (dev); + matsushita_close (dev); - /* Unlink dev. */ - if (first_dev == dev) { - first_dev = dev->next; + /* Unlink dev. */ + if (first_dev == dev) + { + first_dev = dev->next; + } + else + { + dev_tmp = first_dev; + while (dev_tmp->next && dev_tmp->next != dev) + { + dev_tmp = dev_tmp->next; } - else { - dev_tmp = first_dev; - while (dev_tmp->next && dev_tmp->next != dev) { - dev_tmp = dev_tmp->next; - } - if (dev_tmp->next != NULL) { - dev_tmp->next = dev_tmp->next->next; - } + if (dev_tmp->next != NULL) + { + dev_tmp->next = dev_tmp->next->next; } + } - matsushita_free (dev); - num_devices--; + matsushita_free (dev); + num_devices--; - DBG (DBG_proc, "sane_close: exit\n"); + DBG (DBG_proc, "sane_close: exit\n"); } void sane_exit (void) { - DBG (DBG_proc, "sane_exit: enter\n"); + DBG (DBG_proc, "sane_exit: enter\n"); - if (devlist) { - free (devlist); - devlist = NULL; - } + if (devlist) + { + free (devlist); + devlist = NULL; + } - DBG (DBG_proc, "sane_exit: exit\n"); + DBG (DBG_proc, "sane_exit: exit\n"); } diff --git a/backend/matsushita.h b/backend/matsushita.h index b4d1fa08d..ce651d4bb 100644 --- a/backend/matsushita.h +++ b/backend/matsushita.h @@ -53,8 +53,8 @@ typedef struct { - unsigned char data[16]; - int len; + unsigned char data[16]; + int len; } CDB; @@ -142,7 +142,7 @@ CDB; /*--------------------------------------------------------------------------*/ static inline int -getbitfield (unsigned char *pageaddr, int mask, int shift) \ +getbitfield (unsigned char *pageaddr, int mask, int shift) { return ((*pageaddr >> shift) & mask); } @@ -173,42 +173,42 @@ getbitfield (unsigned char *pageaddr, int mask, int shift) \ enum Matsushita_Option { - OPT_NUM_OPTS = 0, + OPT_NUM_OPTS = 0, - OPT_MODE_GROUP, - OPT_MODE, /* scanner modes */ - OPT_RESOLUTION, /* X and Y resolution */ - OPT_DUPLEX, /* Duplex mode */ - OPT_FEEDER_MODE, /* Feeding mode */ + OPT_MODE_GROUP, + OPT_MODE, /* scanner modes */ + OPT_RESOLUTION, /* X and Y resolution */ + OPT_DUPLEX, /* Duplex mode */ + OPT_FEEDER_MODE, /* Feeding mode */ - OPT_GEOMETRY_GROUP, - OPT_PAPER_SIZE, /* Paper size */ - OPT_TL_X, /* upper left X */ - OPT_TL_Y, /* upper left Y */ - OPT_BR_X, /* bottom right X */ - OPT_BR_Y, /* bottom right Y */ + OPT_GEOMETRY_GROUP, + OPT_PAPER_SIZE, /* Paper size */ + OPT_TL_X, /* upper left X */ + OPT_TL_Y, /* upper left Y */ + OPT_BR_X, /* bottom right X */ + OPT_BR_Y, /* bottom right Y */ - OPT_ENHANCEMENT_GROUP, - OPT_BRIGHTNESS, /* Brightness */ - OPT_CONTRAST, /* Contrast */ - OPT_AUTOMATIC_THRESHOLD, /* Automatic threshold */ - OPT_HALFTONE_PATTERN, /* Halftone pattern */ - OPT_AUTOMATIC_SEPARATION, /* Automatic separation */ - OPT_WHITE_LEVEL, /* White level */ - OPT_NOISE_REDUCTION, /* Noise reduction */ - OPT_IMAGE_EMPHASIS, /* Image emphasis */ - OPT_GAMMA, /* Gamma */ + OPT_ENHANCEMENT_GROUP, + OPT_BRIGHTNESS, /* Brightness */ + OPT_CONTRAST, /* Contrast */ + OPT_AUTOMATIC_THRESHOLD, /* Automatic threshold */ + OPT_HALFTONE_PATTERN, /* Halftone pattern */ + OPT_AUTOMATIC_SEPARATION, /* Automatic separation */ + OPT_WHITE_LEVEL, /* White level */ + OPT_NOISE_REDUCTION, /* Noise reduction */ + OPT_IMAGE_EMPHASIS, /* Image emphasis */ + OPT_GAMMA, /* Gamma */ - /* must come last: */ - NUM_OPTIONS + /* must come last: */ + NUM_OPTIONS }; typedef union { - SANE_Word w; /* word */ - SANE_Word *wa; /* word array */ - SANE_String s; /* string */ + SANE_Word w; /* word */ + SANE_Word *wa; /* word array */ + SANE_String s; /* string */ } Option_Value; @@ -240,27 +240,28 @@ SANE_I18N("Automatic separation") /* Differences between the scanners. * The scsi_* fields are used to lookup the correcte entry. */ -struct scanners_supported { - int scsi_type; - char scsi_vendor[9]; - char scsi_product[17]; +struct scanners_supported +{ + int scsi_type; + char scsi_vendor[9]; + char scsi_product[17]; - SANE_Range x_range; - SANE_Range y_range; - SANE_Range brightness_range; - SANE_Range contrast_range; + SANE_Range x_range; + SANE_Range y_range; + SANE_Range brightness_range; + SANE_Range contrast_range; - SANE_String_Const *scan_mode_list; /* array of scan modes */ - const SANE_Word *resolutions_list; /* array of available resolutions */ - const SANE_Word *resolutions_round; /* rounding values for each resolutions */ - - SANE_String_Const *image_emphasis_list; /* list of image emphasis options */ - const int *image_emphasis_val; /* list of image emphasis values */ + SANE_String_Const *scan_mode_list; /* array of scan modes */ + const SANE_Word *resolutions_list; /* array of available resolutions */ + const SANE_Word *resolutions_round; /* rounding values for each resolutions */ - /* Scanner capabilities. */ - int cap; /* bit field */ -#define MAT_CAP_DUPLEX 0x00000002 /* can do duplex */ -#define MAT_CAP_CONTRAST 0x00000004 /* have contrast */ + SANE_String_Const *image_emphasis_list; /* list of image emphasis options */ + const int *image_emphasis_val; /* list of image emphasis values */ + + /* Scanner capabilities. */ + int cap; /* bit field */ +#define MAT_CAP_DUPLEX 0x00000002 /* can do duplex */ +#define MAT_CAP_CONTRAST 0x00000004 /* have contrast */ #define MAT_CAP_AUTOMATIC_THRESHOLD 0x00000008 #define MAT_CAP_WHITE_LEVEL 0x00000010 #define MAT_CAP_GAMMA 0x00000020 @@ -271,10 +272,11 @@ struct scanners_supported { #define MAT_CAP_MANUAL_FEED 0x00000400 }; -struct paper_sizes { - SANE_String_Const name; /* name of the paper */ - int width; - int length; +struct paper_sizes +{ + SANE_String_Const name; /* name of the paper */ + int width; + int length; }; /*--------------------------------------------------------------------------*/ @@ -282,68 +284,68 @@ struct paper_sizes { /* Define a scanner occurence. */ typedef struct Matsushita_Scanner { - struct Matsushita_Scanner *next; - SANE_Device sane; + struct Matsushita_Scanner *next; + SANE_Device sane; - char *devicename; - int sfd; /* device handle */ + char *devicename; + int sfd; /* device handle */ - /* Infos from inquiry. */ - char scsi_type; - char scsi_vendor[9]; - char scsi_product[17]; - char scsi_version[5]; + /* Infos from inquiry. */ + char scsi_type; + char scsi_vendor[9]; + char scsi_product[17]; + char scsi_version[5]; - /* Scanner infos. */ - int scnum; /* index of that scanner in - * scanners_supported */ + /* Scanner infos. */ + int scnum; /* index of that scanner in + * scanners_supported */ - SANE_String_Const *paper_sizes_list; /* names of supported papers */ - int *paper_sizes_val; /* indirection into paper_sizes[] */ + SANE_String_Const *paper_sizes_list; /* names of supported papers */ + int *paper_sizes_val; /* indirection into paper_sizes[] */ - /* SCSI handling */ - size_t buffer_size; /* size of the buffer */ - SANE_Byte *buffer; /* for SCSI transfer. */ + /* SCSI handling */ + size_t buffer_size; /* size of the buffer */ + SANE_Byte *buffer; /* for SCSI transfer. */ - /* Scanning handling. */ - int scanning; /* TRUE if a scan is running. */ - int resolution; /* resolution in DPI, for both X and Y */ - int x_tl; /* X top left */ - int y_tl; /* Y top left */ - int x_br; /* X bottom right */ - int y_br; /* Y bottom right */ - int width; /* width of the scan area in mm */ - int length; /* length of the scan area in mm */ + /* Scanning handling. */ + int scanning; /* TRUE if a scan is running. */ + int resolution; /* resolution in DPI, for both X and Y */ + int x_tl; /* X top left */ + int y_tl; /* Y top left */ + int x_br; /* X bottom right */ + int y_br; /* Y bottom right */ + int width; /* width of the scan area in mm */ + int length; /* length of the scan area in mm */ - enum - { - MATSUSHITA_BW, - MATSUSHITA_HALFTONE, - MATSUSHITA_GRAYSCALE - } - scan_mode; + enum + { + MATSUSHITA_BW, + MATSUSHITA_HALFTONE, + MATSUSHITA_GRAYSCALE + } + scan_mode; - int depth; /* depth per color */ - int halftone_pattern; /* haltone number, valid for MATSUSHITA_HALFTONE */ + int depth; /* depth per color */ + int halftone_pattern; /* haltone number, valid for MATSUSHITA_HALFTONE */ - int bytes_left; /* number of bytes promised to backend - * left to read. */ + int bytes_left; /* number of bytes promised to backend + * left to read. */ - SANE_Parameters params; + SANE_Parameters params; - int page_side; /* 0=front, 1=back */ - int page_num; /* current number of the page */ + int page_side; /* 0=front, 1=back */ + int page_num; /* current number of the page */ - /* For Grayscale 4 bits only */ - SANE_Byte *image; /* keep the current image there */ - size_t image_size; /* allocated size of image */ - size_t image_begin; /* first significant byte in image */ - size_t image_end; /* first free byte in image */ + /* For Grayscale 4 bits only */ + SANE_Byte *image; /* keep the current image there */ + size_t image_size; /* allocated size of image */ + size_t image_begin; /* first significant byte in image */ + size_t image_end; /* first free byte in image */ - /* Options */ - SANE_Option_Descriptor opt[NUM_OPTIONS]; - Option_Value val[NUM_OPTIONS]; + /* Options */ + SANE_Option_Descriptor opt[NUM_OPTIONS]; + Option_Value val[NUM_OPTIONS]; } Matsushita_Scanner;