Lines Matching refs:cs
87 static SANE_Status fix_weights_file(CANONP_Scanner *cs);
89 static SANE_Status detect_mode(CANONP_Scanner *cs);
510 CANONP_Scanner *cs;
534 cs = first_dev;
535 while((cs != NULL) && strcmp(cs->params.port->name, name))
536 cs = cs->next;
540 if ((cs == NULL) || (cs->scanner_present != SANE_TRUE))
542 cs = first_dev;
543 while((cs != NULL) &&
544 (cs->scanner_present == SANE_FALSE))
545 cs = cs->next;
552 cs = first_dev;
553 while((cs != NULL) && strcmp(cs->params.port->name, name))
554 cs = cs->next;
558 if (cs == NULL)
564 if (cs->scanner_present == SANE_FALSE)
570 if (cs->opened == SANE_TRUE)
578 if (cs->setup == SANE_TRUE)
580 cs->opened = SANE_TRUE;
581 *h = (SANE_Handle)cs;
585 tmp = ieee1284_claim(cs->params.port);
594 tmp = sanei_canon_pp_initialise(&(cs->params), cs->init_mode);
603 ieee1284_release(cs->params.port);
607 if (cs->weights_file != NULL)
609 cs->weights_file,
610 (const void *)(&(cs->params)));
613 (const void *)(&(cs->params)));
614 tmp = sanei_canon_pp_load_weights(cs->weights_file, &(cs->params));
623 cs->cal_valid = SANE_FALSE;
625 cs->cal_valid = SANE_TRUE;
628 tmp = sanei_canon_pp_adjust_gamma(&(cs->params));
634 sanei_canon_pp_check_status(cs->params.port));
642 if (cs->params.scanheadwidth == 2552)
643 cs->opt[OPT_RESOLUTION].constraint.word_list = res300;
645 cs->opt[OPT_RESOLUTION].constraint.word_list = res600;
653 cs->opt[OPT_TL_X].constraint.range = tmp_range;
660 cs->opt[OPT_TL_Y].constraint.range = tmp_range;
667 cs->opt[OPT_BR_X].constraint.range = tmp_range;
674 cs->opt[OPT_BR_Y].constraint.range = tmp_range;
677 cs->opened = SANE_TRUE;
678 cs->setup = SANE_TRUE;
680 *h = (SANE_Handle)cs;
697 CANONP_Scanner *cs = ((CANONP_Scanner *)h);
711 if (cs->opened == SANE_FALSE)
720 return (cs->opt + opt);
735 CANONP_Scanner *cs = ((CANONP_Scanner *)h);
758 if (cs->opened == SANE_FALSE)
765 if (cs->scanning == SANE_TRUE)
779 cmodes[cs->vals[opt]]);
783 depths[cs->vals[opt]]);
786 *((int *)val) = res600[cs->vals[opt]];
789 *((int *)val) = cs->vals[opt];
802 i = cs->vals[opt];
803 cs->vals[opt] = 1;
804 maxresi = cs->opt[OPT_RESOLUTION].
807 while ((cs->vals[opt] <= maxresi) &&
808 (res600[cs->vals[opt]]
811 cs->vals[opt] += 1;
814 if (res600[cs->vals[opt]] !=
822 cs->vals[opt] = 0;
823 while ((cmodes[cs->vals[opt]] != NULL)
824 && strcmp(cmodes[cs->vals[opt]],
827 cs->vals[opt] += 1;
833 cs->vals[opt] = 0;
834 while ((depths[cs->vals[opt]] != NULL)
835 && strcmp(depths[cs->vals[opt]],
838 cs->vals[opt] += 1;
847 if ((i<cs->opt[opt].constraint.range->min) || (i>cs->opt[opt].constraint.range->max))
849 cs->vals[opt] = i;
853 if ((cs->weights_file==NULL) ||
854 cs->cal_readonly
861 cs->weights_file);
863 if (cs->cal_readonly) tmp =
865 &(cs->params),
868 &(cs->params),
869 cs->weights_file);
879 cs->cal_valid =
883 cs->cal_valid =
889 if (i) cs->vals[opt] = 1;
890 else cs->vals[opt] = 0;
924 CANONP_Scanner *cs = ((CANONP_Scanner *)h);
930 if (cs->opened == SANE_FALSE)
939 res = res600[cs->vals[OPT_RESOLUTION]];
949 ((cs->vals[OPT_BR_X] - cs->vals[OPT_TL_X]) * res) / MM_PER_IN;
950 params->lines = ((cs->vals[OPT_BR_Y] - cs->vals[OPT_TL_Y]) * res)
955 max_res = cs->params.scanheadwidth == 2552 ? 300 : 600;
963 max_width = cs->params.scanheadwidth / (max_res / res);
965 max_height = (cs->params.scanheadwidth == 2552 ? 3508 : 7016) /
973 params->depth = cs->vals[OPT_DEPTH] ? 16 : 8;
975 switch (cs->vals[OPT_COLOUR_MODE])
998 (cs->vals[OPT_COLOUR_MODE] ? 3 : 1);
1004 max_res, res, max_height, cs->vals[OPT_BR_Y],
1005 cs->vals[OPT_TL_Y], MM_PER_IN);
1023 CANONP_Scanner *cs = ((CANONP_Scanner *)h);
1028 if (cs->scanning) return SANE_STATUS_DEVICE_BUSY;
1029 if (cs->opened == SANE_FALSE)
1039 res = res600[cs->vals[OPT_RESOLUTION]];
1042 cs->scan.width = ((cs->vals[OPT_BR_X] - cs->vals[OPT_TL_X]) * res)
1044 cs->scan.height = ((cs->vals[OPT_BR_Y] - cs->vals[OPT_TL_Y]) * res)
1047 cs->scan.xoffset = (cs->vals[OPT_TL_X] * res) / MM_PER_IN;
1048 cs->scan.yoffset = (cs->vals[OPT_TL_Y] * res) / MM_PER_IN;
1058 max_res = cs->params.scanheadwidth == 2552 ? 300 : 600;
1061 cs->scan.width -= (cs->scan.width%4);
1062 cs->scan.xoffset -= (cs->scan.xoffset%4);
1065 if (cs->scan.width < 64) cs->scan.width = 64;
1067 max_width = cs->params.scanheadwidth / (max_res / res);
1069 max_height = (cs->params.scanheadwidth == 2552 ? 3508 : 7016) /
1072 if (cs->scan.width > max_width) cs->scan.width = max_width;
1073 if (cs->scan.width + cs->scan.xoffset > max_width) cs->scan.xoffset =
1074 max_width - cs->scan.width;
1075 if (cs->scan.height > max_height) cs->scan.height = max_height;
1096 cs->scan.xresolution = i;
1097 cs->scan.yresolution = i;
1099 if (((cs->vals[OPT_BR_Y] - cs->vals[OPT_TL_Y]) <= 0) ||
1100 ((cs->vals[OPT_BR_X] - cs->vals[OPT_TL_X]) <= 0))
1104 cs->scan.height, cs->scan.width);
1108 cs->scan.mode = cs->vals[OPT_COLOUR_MODE];
1111 tmp = sanei_canon_pp_init_scan(&(cs->params), &(cs->scan));
1118 cs->scanning = SANE_TRUE;
1119 cs->cancelled = SANE_FALSE;
1120 cs->sent_eof = SANE_FALSE;
1121 cs->lines_scanned = 0;
1122 cs->bytes_sent = 0;
1140 CANONP_Scanner *cs = ((CANONP_Scanner *)h);
1184 cs->bytes_sent += bytesleft;
1193 cs->bytes_sent += maxlen;
1203 if (((unsigned)cs->scan.height <= (unsigned)cs->lines_scanned)
1204 || (cs->sent_eof) || !(cs->scanning))
1206 cs->sent_eof = SANE_TRUE;
1207 cs->scanning = SANE_FALSE;
1208 cs->cancelled = SANE_FALSE;
1209 cs->lines_scanned = 0;
1210 cs->bytes_sent = 0;
1220 if (cs->vals[OPT_DEPTH] == 0)
1221 bpl = cs->scan.width * (cs->vals[OPT_COLOUR_MODE] ? 3 : 1);
1223 bpl = cs->scan.width * (cs->vals[OPT_COLOUR_MODE] ? 6 : 2);
1230 if (lines > (cs->scan.height - cs->lines_scanned))
1231 lines = cs->scan.height - cs->lines_scanned;
1254 cs->params.scanheadwidth,
1255 cs->params.natural_xresolution,
1256 cs->params.natural_yresolution,
1257 cs->params.max_xresolution,
1258 cs->params.max_yresolution,
1259 (cs->params.id_string)+8);
1263 cs->scan.width, cs->scan.height,
1264 cs->scan.xoffset, cs->scan.yoffset,
1265 cs->scan.xresolution, cs->scan.yresolution,
1266 cs->scan.mode, lines);
1269 lines, cs->cal_valid,
1270 cs->scan.height - cs->lines_scanned);
1271 tmp = sanei_canon_pp_read_segment(&is, &(cs->params), &(cs->scan),
1272 lines, cs->cal_valid,
1273 cs->scan.height - cs->lines_scanned);
1277 if (cs->cancelled)
1280 cs->sent_eof = SANE_TRUE;
1281 cs->scanning = SANE_FALSE;
1283 sanei_canon_pp_abort_scan(&(cs->params));
1292 cs->lines_scanned += lines;
1295 if (cs->vals[OPT_DEPTH] == 0)
1301 if (cs->vals[OPT_COLOUR_MODE])
1315 if (cs->vals[OPT_COLOUR_MODE])
1341 cs->bytes_sent += bytes;
1349 cs->bytes_sent += maxlen;
1354 if ((unsigned)cs->lines_scanned >= cs->scan.height)
1359 cs->scanning = SANE_FALSE;
1360 cs->lines_scanned = 0;
1361 cs->bytes_sent = 0;
1380 CANONP_Scanner *cs = ((CANONP_Scanner *)h);
1387 if (!(cs->scanning))
1393 cs->cancelled = SANE_TRUE;
1394 cs->params.abort_now = 1;
1411 CANONP_Scanner *cs = ((CANONP_Scanner *)h);
1415 if (cs->opened == SANE_FALSE)
1423 sanei_canon_pp_close_scanner(&(cs->params));
1425 cs->opened = SANE_FALSE;
1428 cs->scanning = SANE_FALSE;
1429 cs->sent_eof = SANE_TRUE;
1431 ieee1284_release(cs->params.port);
1566 CANONP_Scanner *cs = NULL;
1570 cs = malloc(sizeof(*cs));
1571 if (cs == NULL)
1575 memset(cs, 0, sizeof(*cs));
1578 if ((cs->params.port = malloc(sizeof(*(cs->params.port)))) == NULL)
1581 memcpy(cs->params.port, pp, sizeof(*pp));
1584 cs->params.port = pp;
1589 cs->params.blackweight = NULL;
1590 cs->params.redweight = NULL;
1591 cs->params.greenweight = NULL;
1592 cs->params.blueweight = NULL;
1595 cs->hw.name = cs->params.port->name;
1596 cs->hw.vendor = hw_vendor;
1597 cs->hw.type = hw_type;
1598 cs->opened = SANE_FALSE;
1599 cs->scanning = SANE_FALSE;
1600 cs->cancelled = SANE_FALSE;
1601 cs->sent_eof = SANE_TRUE;
1602 cs->lines_scanned = 0;
1603 cs->bytes_sent = 0;
1604 cs->init_mode = INITMODE_AUTO;
1611 cs->opt[i].name = opt_names[i];
1612 cs->opt[i].title = opt_titles[i];
1613 cs->opt[i].desc = opt_descs[i];
1614 cs->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
1615 cs->opt[i].type = SANE_TYPE_INT;
1616 cs->opt[i].size = sizeof(SANE_Int);
1622 cs->opt[OPT_NUM_OPTIONS].unit = SANE_UNIT_NONE;
1623 cs->opt[OPT_NUM_OPTIONS].cap = SANE_CAP_SOFT_DETECT;
1624 cs->vals[OPT_NUM_OPTIONS] = NUM_OPTIONS;
1629 cs->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
1630 cs->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
1632 cs->vals[OPT_RESOLUTION] = 1;
1637 cs->opt[OPT_COLOUR_MODE].type = SANE_TYPE_STRING;
1638 cs->opt[OPT_COLOUR_MODE].size = 20;
1639 cs->opt[OPT_COLOUR_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1641 cs->opt[OPT_COLOUR_MODE].constraint.string_list = cmodes;
1646 cs->opt[OPT_DEPTH].type = SANE_TYPE_STRING;
1647 cs->opt[OPT_DEPTH].size = 20;
1648 cs->opt[OPT_DEPTH].cap |= SANE_CAP_EMULATED;
1649 cs->opt[OPT_DEPTH].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1650 cs->opt[OPT_DEPTH].constraint.string_list = depths;
1655 cs->opt[OPT_TL_X].unit = SANE_UNIT_MM;
1656 cs->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
1661 cs->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
1662 cs->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1667 cs->opt[OPT_BR_X].unit = SANE_UNIT_MM;
1668 cs->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
1670 cs->vals[OPT_BR_X] = 100;
1675 cs->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
1676 cs->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1677 cs->vals[OPT_BR_Y] = 100;
1682 cs->opt[OPT_CAL].type = SANE_TYPE_BUTTON;
1683 cs->opt[OPT_CAL].constraint_type = SANE_CONSTRAINT_NONE;
1684 if (cs->cal_readonly)
1685 cs->opt[OPT_CAL].cap |= SANE_CAP_INACTIVE;
1689 cs->opt[OPT_GAMMA_R].caps |= SANE_CAP_ADVANCED;
1690 cs->opt[OPT_GAMMA_G].caps |= SANE_CAP_ADVANCED;
1691 cs->opt[OPT_GAMMA_B].caps |= SANE_CAP_ADVANCED;
1702 cs->next = first_dev;
1703 first_dev = cs;
1788 static SANE_Status fix_weights_file(CANONP_Scanner *cs)
1797 if (cs == NULL)
1805 cs->cal_readonly = SANE_FALSE;
1807 if (cs->weights_file == NULL)
1811 strlen(cs->params.port->name);
1812 if ((cs->weights_file = malloc(i + 1)) == NULL)
1814 sprintf(cs->weights_file, "%s%s", default_weights_file_prefix,
1815 cs->params.port->name);
1819 if (cs->weights_file[0] == '~')
1827 i = strlen(myhome) + strlen(&cs->weights_file[1]);
1830 sprintf(tmp, "%s%s", myhome, &cs->weights_file[1]);
1832 free(cs->weights_file);
1833 cs->weights_file = tmp;
1840 if(stat(cs->weights_file, f_stat))
1844 if ((errno != ENOENT) || init_cal(cs->weights_file))
1851 free(cs->weights_file);
1852 cs->weights_file = NULL;
1859 i = open(cs->weights_file, O_RDWR | O_APPEND);
1864 i = open(cs->weights_file, O_RDONLY);
1872 free(cs->weights_file);
1873 cs->weights_file = NULL;
1879 cs->cal_readonly = SANE_TRUE;
1900 * cs->params.port is not open
1902 * cs->params.port is left opened iff SANE_STATUS_GOOD returned.
1905 SANE_Status detect_mode(CANONP_Scanner *cs)
1911 DBG(10,"detect_mode: Opening port %s\n", (cs->params.port->name));
1913 tmp = ieee1284_open(cs->params.port, 0, &capabilities);
1938 if (ieee1284_claim(cs->params.port) != E1284_OK)
1941 ieee1284_close(cs->params.port);
1951 ieee1284_release(cs->params.port);
1952 ieee1284_close(cs->params.port);
1969 cs->ieee1284_mode = M1284_ECP;
1974 cs->ieee1284_mode = M1284_ECPSWE;
1979 cs->ieee1284_mode = M1284_NIBBLE;
1985 ieee1284_release(cs->params.port);
1986 ieee1284_close(cs->params.port);
1998 if ((cs->ieee1284_mode == M1284_ECP) ||
1999 (cs->ieee1284_mode == M1284_ECPSWE))
2013 if (ieee1284_ecp_read_data(cs->params.port, 0, NULL, 0) ==
2019 cs->ieee1284_mode = M1284_NIBBLE;
2026 cs->ieee1284_mode = M1284_NIBBLE;
2029 ieee1284_release(cs->params.port);
2031 sanei_canon_pp_set_ieee1284_mode(cs->ieee1284_mode);