mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Add imageclass devices by configuration

pixma-add-model-by-description
Ordissimo 2023-09-27 15:41:52 +02:00
rodzic 14b5bce021
commit 9b43402b13
6 zmienionych plików z 246 dodań i 95 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

11
backend/pixma.conf.in
Wyświetl plik

@ -31,5 +31,12 @@
# Example using for a scanner using mfnp including the optional timeout:
# mfnp://scanner.bad-network.org/timeout=1500
# device NAME MODEL PID DPI CAPACITE
# device "Canon PIXMA TS2600 Series" "TS2600" 0x1107 600 PIXMA_CAP_CIS
# TYPE : MP150 OR ICLASS
#
# device MP150 NAME MODEL PID DPI CAPACITE
# device MP150 "Canon PIXMA TS2600 Series" "TS2600" 0x1107 600 PIXMA_CAP_CIS
#
#
# device ICLASS NAME MODEL PID DPI ADF_DPI WIDTH HEIGHT CAPACITE
# device ICLASS "Canon i-SENSYS MF630 Series" "MF630" 0x27e1 600 0 637 1050 PIXMA_CAP_ADFDUP

178
backend/pixma/pixma.c
Wyświetl plik

@ -153,6 +153,7 @@ static const SANE_Device **dev_list = NULL;
static const char* conf_devices[MAX_CONF_DEVICES];
void pixma_add_custom_mp150_device (const char *, const char *, const char *, const char *, const char *);
void pixma_add_custom_iclass_device (const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *);
static void mark_all_button_options_cached ( struct pixma_sane_t * ss )
{
@ -161,60 +162,143 @@ static void mark_all_button_options_cached ( struct pixma_sane_t * ss )
ss -> button_option_is_cached[i] = 1;
}
static SANE_Status config_attach_pixma(SANEI_Config __sane_unused__ * config,
const char *line,
void __sane_unused__ *data)
static SANE_Status config_attach_pixma_generic (const char *line)
{
int i;
if (*line == '#') return SANE_STATUS_GOOD;
if (strncmp(line, "device", 6) == 0) {
char *name_str = NULL;
char *model_str = NULL;
char *pid_str = NULL;
char *dpi_str = NULL;
char *capacity_str = NULL;
// # DEVICE NAME MODEL PID DPI CAPACITE
PDBG (pixma_dbg (3, "New define pixma description (%s)\n", line));
line = sanei_config_get_string(line + 6, &name_str);
if (!name_str || !*name_str) {
PDBG (pixma_dbg (3, "Pixma name missing.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma name is [%s].\n", name_str));
line = sanei_config_get_string(line, &model_str);
if (!model_str || !*model_str) {
PDBG (pixma_dbg (3, "Pixma model missing.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma model is [%s].\n", model_str));
line = sanei_config_get_string(line, &pid_str);
if (!pid_str || !*pid_str) {
PDBG (pixma_dbg (3, "Pixma usbid missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma pid is [%s].\n", pid_str));
line = sanei_config_get_string(line, &dpi_str);
if (!dpi_str || !*dpi_str) {
PDBG (pixma_dbg (3, "Pixma dpi missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma dpi is [%s].\n", dpi_str));
line = sanei_config_get_string(line, &capacity_str);
if (!capacity_str || !*capacity_str) {
PDBG (pixma_dbg (3, "Pixma capacity missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma capacity is [%s].\n", capacity_str));
pixma_add_custom_mp150_device (name_str, model_str, pid_str, dpi_str, capacity_str);
return SANE_STATUS_GOOD;
}
else {
int i;
for (i=0; i < (MAX_CONF_DEVICES -1); i++) {
if (conf_devices[i] == NULL) {
conf_devices[i] = strdup(line);
return SANE_STATUS_GOOD;
}
}
return SANE_STATUS_INVAL;
}
static SANE_Status config_attach_pixma(SANEI_Config __sane_unused__ * config,
const char *line,
void __sane_unused__ *data)
{
if (*line == '#') return SANE_STATUS_GOOD;
if (strncmp(line, "device", 6) == 0) {
char *type_str = NULL;
line = sanei_config_get_string(line + 6, &type_str);
if (!type_str || !*type_str) {
PDBG (pixma_dbg (3, "Canon Type device missing.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Canon Type device is [%s].\n", type_str));
if (strcmp(type_str, "MP150") == 0) {
char *name_str = NULL;
char *model_str = NULL;
char *pid_str = NULL;
char *dpi_str = NULL;
char *capacity_str = NULL;
// # DEVICE NAME MODEL PID DPI CAPACITE
PDBG (pixma_dbg (3, "New define pixma description (%s)\n", line));
line = sanei_config_get_string(line , &name_str);
if (!name_str || !*name_str) {
PDBG (pixma_dbg (3, "Pixma name missing.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma name is [%s].\n", name_str));
line = sanei_config_get_string(line, &model_str);
if (!model_str || !*model_str) {
PDBG (pixma_dbg (3, "Pixma model missing.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma model is [%s].\n", model_str));
line = sanei_config_get_string(line, &pid_str);
if (!pid_str || !*pid_str) {
PDBG (pixma_dbg (3, "Pixma usbid missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma pid is [%s].\n", pid_str));
line = sanei_config_get_string(line, &dpi_str);
if (!dpi_str || !*dpi_str) {
PDBG (pixma_dbg (3, "Pixma dpi missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma dpi is [%s].\n", dpi_str));
line = sanei_config_get_string(line, &capacity_str);
if (!capacity_str || !*capacity_str) {
PDBG (pixma_dbg (3, "Pixma capacity missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma capacity is [%s].\n", capacity_str));
pixma_add_custom_mp150_device (name_str, model_str, pid_str, dpi_str, capacity_str);
return SANE_STATUS_GOOD;
}
else if (strcmp(type_str, "ICLASS") == 0) {
char *name_str = NULL;
char *model_str = NULL;
char *pid_str = NULL;
char *dpi_str = NULL;
char *adpi_str = NULL;
char *w_str = NULL;
char *h_str = NULL;
char *capacity_str = NULL;
// # DEVICE NAME MODEL PID DPI ADF_DPI WIDTH HEIGHT CAPACITE
PDBG (pixma_dbg (3, "New define iclass description (%s)\n", line));
line = sanei_config_get_string(line , &name_str);
if (!name_str || !*name_str) {
PDBG (pixma_dbg (3, "Iclass name missing.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Iclass name is [%s].\n", name_str));
line = sanei_config_get_string(line, &model_str);
if (!model_str || !*model_str) {
PDBG (pixma_dbg (3, "Iclass model missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Iclass model is [%s].\n", model_str));
line = sanei_config_get_string(line, &pid_str);
if (!pid_str || !*pid_str) {
PDBG (pixma_dbg (3, "Iclass pid missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Iclass pid is [%s].\n", pid_str));
line = sanei_config_get_string(line, &dpi_str);
if (!dpi_str || !*dpi_str) {
PDBG (pixma_dbg (3, "Pixma dpi missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma dpi is [%s].\n", dpi_str));;
line = sanei_config_get_string(line, &adpi_str);
if (!adpi_str || !*adpi_str) {
PDBG (pixma_dbg (3, "Pixma adf-dpi missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma adf-dpi is [%s].\n", adpi_str));
line = sanei_config_get_string(line, &w_str);
if (!w_str || !*w_str) {
PDBG (pixma_dbg (3, "Pixma width missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma width is [%s].\n", w_str));
line = sanei_config_get_string(line, &h_str);
if (!h_str || !*h_str) {
PDBG (pixma_dbg (3, "Pixma height missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma height is [%s].\n", h_str));
line = sanei_config_get_string(line, &capacity_str);
if (!capacity_str || !*capacity_str) {
PDBG (pixma_dbg (3, "Pixma capacity missig.\n"));
return SANE_STATUS_INVAL;
}
PDBG (pixma_dbg (3, "Pixma capacity is [%s].\n", capacity_str));
pixma_add_custom_iclass_device (name_str, model_str, pid_str, dpi_str, adpi_str, w_str, h_str, capacity_str);
return SANE_STATUS_GOOD;
}
else {
return config_attach_pixma_generic (line);
}
}
else {
return config_attach_pixma_generic (line);
}
return SANE_STATUS_INVAL;
}

3
backend/pixma/pixma.h
Wyświetl plik

@ -378,6 +378,9 @@ struct pixma_scan_param_t
unsigned frontend_cancel;
};
extern const char *ccaps[18];
extern const unsigned ucaps[18];
/** PIXMA model information */
struct pixma_config_t
{

65
backend/pixma/pixma_common.c
Wyświetl plik

@ -76,6 +76,8 @@ extern const pixma_config_t pixma_mp800_devices[];
extern const pixma_config_t pixma_iclass_devices[];
extern pixma_config_t *pixma_custom_mp150_devices;
extern int pixma_custom_mp150_devices_count;
extern pixma_config_t *pixma_custom_iclass_devices;
extern int pixma_custom_iclass_devices_count;
static const pixma_config_t *const pixma_devices[] = {
pixma_mp150_devices,
@ -1225,17 +1227,26 @@ pixma_fill_gamma_table (double gamma, uint8_t * table, unsigned n)
int
pixma_find_scanners (const char **conf_devices, SANE_Bool local_only)
{
if (pixma_custom_mp150_devices_count > 0) {
if (pixma_custom_mp150_devices_count > 0 || pixma_custom_iclass_devices_count > 0) {
int i = 0;
const pixma_config_t **pixma_devices_all = (const pixma_config_t **)calloc(7, sizeof(pixma_config_t *));
const pixma_config_t **pixma_devices_all = (const pixma_config_t **)calloc(8, sizeof(pixma_config_t *));
for (i = 0; i < 6; i++)
pixma_devices_all[i] = pixma_devices[i];
pixma_devices_all[5] = pixma_custom_mp150_devices;
pixma_devices_all[6] = NULL;
PDBG (pixma_dbg (3, "Add custom devices in pixma_devices\n"));
i = 5;
if (pixma_custom_mp150_devices_count > 0) {
pixma_devices_all[i] = pixma_custom_mp150_devices;
i++;
pixma_devices_all[i] = NULL;
PDBG (pixma_dbg (3, "Add custom devices mp150 in pixma_devices\n"));
}
if (pixma_custom_mp150_devices_count > 0) {
pixma_devices_all[i] = pixma_custom_iclass_devices;
i++;
pixma_devices_all[i] = NULL;
PDBG (pixma_dbg (3, "Add custom devices iclass in pixma_devices\n"));
}
return pixma_collect_devices (conf_devices, pixma_devices_all, local_only);
}
PDBG (pixma_dbg (3, "No custom devices in pixma_devices\n"));
};
return pixma_collect_devices (conf_devices, pixma_devices, local_only);
}
@ -1365,4 +1376,44 @@ clean:
xmlFreeDoc(doc);
return status;
}
const char *ccaps [18] = {"PIXMA_CAP_EASY_RGB",
"PIXMA_CAP_GRAY",
"PIXMA_CAP_ADF",
"PIXMA_CAP_48BIT",
"PIXMA_CAP_GAMMA_TABLE",
"PIXMA_CAP_EVENTS",
"PIXMA_CAP_TPU",
"PIXMA_CAP_ADFDUP",
"PIXMA_CAP_CIS",
"PIXMA_CAP_CCD",
"PIXMA_CAP_LINEART",
"PIXMA_CAP_NEGATIVE",
"PIXMA_CAP_TPUIR",
"PIXMA_CAP_ADF_WAIT",
"PIXMA_CAP_ADF_JPEG",
"PIXMA_CAP_JPEG",
"PIXMA_CAP_GT_4096",
NULL
};
const unsigned ucaps [18] = {PIXMA_CAP_EASY_RGB,
PIXMA_CAP_GRAY,
PIXMA_CAP_ADF,
PIXMA_CAP_48BIT,
PIXMA_CAP_GAMMA_TABLE,
PIXMA_CAP_EVENTS,
PIXMA_CAP_TPU,
PIXMA_CAP_ADFDUP,
PIXMA_CAP_CIS,
PIXMA_CAP_CCD,
PIXMA_CAP_LINEART,
PIXMA_CAP_NEGATIVE,
PIXMA_CAP_TPUIR,
PIXMA_CAP_ADF_WAIT,
PIXMA_CAP_ADF_JPEG,
PIXMA_CAP_JPEG,
PIXMA_CAP_GT_4096,
0
};
#endif

45
backend/pixma/pixma_imageclass.c
Wyświetl plik

@ -162,6 +162,8 @@ typedef struct iclass_t
uint8_t adf_state; /* handle adf scanning */
} iclass_t;
pixma_config_t *pixma_custom_iclass_devices = NULL;
int pixma_custom_iclass_devices_count = 0;
static int is_scanning_from_adf (pixma_t * s)
{
@ -994,3 +996,46 @@ const pixma_config_t pixma_iclass_devices[] = {
DEV ("Canon i-SENSYS MF440 Series", "MF440", MF440_PID, 600, 300, 637, 877, PIXMA_CAP_ADFDUP),
DEV (NULL, NULL, 0, 0, 0, 0, 0, 0)
};
void
pixma_add_custom_iclass_device (const char *name,
const char *model,
const char *pid,
const char *dpi,
const char *adf_dpi,
const char *w,
const char *h,
const char *capacity)
{
int ddpi = 0;
int dadpi = 0;
int dw = 0;
int dh = 0;
uint16_t ppid = 0;
unsigned caps = 0;
int lcaps = 0;
if (pixma_custom_iclass_devices_count == 0) {
pixma_custom_iclass_devices = (pixma_config_t *)calloc (2, sizeof(pixma_config_t));
} else {
pixma_custom_iclass_devices = realloc (pixma_custom_iclass_devices, sizeof(pixma_config_t) * (pixma_custom_iclass_devices_count + 2));
}
while (ccaps[lcaps] != NULL) {
if(strstr(capacity, ccaps[lcaps]) != NULL) {
caps = caps | ucaps[lcaps];
}
lcaps++;
}
ddpi = atoi(dpi);
dadpi = atoi(adf_dpi);
dw = atoi(w);
dh = atoi(h);
ppid = (uint16_t)strtoll(pid, NULL, 16);
pixma_config_t elem = DEV (name, model, ppid, ddpi, dadpi, dw, dh, caps);
pixma_custom_iclass_devices[pixma_custom_iclass_devices_count] = elem;
pixma_config_t noelem = DEV (NULL, NULL, 0, 0, 0, 0, 0, 0);
pixma_custom_iclass_devices[(pixma_custom_iclass_devices_count + 1)] = noelem;
pixma_custom_iclass_devices_count++;
}

39
backend/pixma/pixma_mp150.c
Wyświetl plik

@ -1972,45 +1972,6 @@ const pixma_config_t pixma_mp150_devices[] = {
END_OF_DEVICE_LIST
};
const char *ccaps [] = {"PIXMA_CAP_EASY_RGB",
"PIXMA_CAP_GRAY",
"PIXMA_CAP_ADF",
"PIXMA_CAP_48BIT",
"PIXMA_CAP_GAMMA_TABLE",
"PIXMA_CAP_EVENTS",
"PIXMA_CAP_TPU",
"PIXMA_CAP_ADFDUP",
"PIXMA_CAP_CIS",
"PIXMA_CAP_CCD",
"PIXMA_CAP_LINEART",
"PIXMA_CAP_NEGATIVE",
"PIXMA_CAP_TPUIR",
"PIXMA_CAP_ADF_WAIT",
"PIXMA_CAP_ADF_JPEG",
"PIXMA_CAP_JPEG",
"PIXMA_CAP_GT_4096",
NULL
};
const unsigned ucaps [] = {PIXMA_CAP_EASY_RGB,
PIXMA_CAP_GRAY,
PIXMA_CAP_ADF,
PIXMA_CAP_48BIT,
PIXMA_CAP_GAMMA_TABLE,
PIXMA_CAP_EVENTS,
PIXMA_CAP_TPU,
PIXMA_CAP_ADFDUP,
PIXMA_CAP_CIS,
PIXMA_CAP_CCD,
PIXMA_CAP_LINEART,
PIXMA_CAP_NEGATIVE,
PIXMA_CAP_TPUIR,
PIXMA_CAP_ADF_WAIT,
PIXMA_CAP_ADF_JPEG,
PIXMA_CAP_JPEG,
PIXMA_CAP_GT_4096
};
void
pixma_add_custom_mp150_device (const char *name,
const char *model,