Lines Matching refs:dev
126 {176, 144, 0, 1, 2}, /* QCIF selected by dev->CIF */
128 {160, 120, 0, 1, 2}, /* QSIF ,, dev->VGA */
244 Stv680_Vidcam *dev;
249 dev = malloc (sizeof (Stv680_Vidcam));
250 if (dev == NULL)
254 memset (dev, 0, sizeof (Stv680_Vidcam));
257 dev->windoww_size = 0x20;
258 dev->windoww = malloc (dev->windoww_size);
259 if (dev->windoww == NULL)
261 free (dev);
266 dev->windowr_size = 0x20;
267 dev->windowr = malloc (dev->windowr_size);
268 if (dev->windowr == NULL)
270 free (dev->windoww);
271 free (dev);
275 dev->fd = -1;
279 return (dev);
283 stv680_init_2 (Stv680_Vidcam * dev)
292 if (dev->CIF)
293 dev->buffer_size = 356 * 292;
294 if (dev->VGA)
295 dev->buffer_size = 644 * 484;
296 DBG (DBG_proc, "stv680_init_2: dev->buffer = 0x%lx\n", (unsigned long) (size_t) dev->buffer_size);
298 dev->buffer = malloc (dev->buffer_size);
300 if (dev->buffer == NULL)
302 free (dev->windowr);
303 free (dev->windoww);
304 free (dev);
309 dev->output_size = dev->buffer_size * 3;
311 dev->output = malloc (dev->output_size);
312 if (dev->output == NULL)
314 free (dev->windowr);
315 free (dev->windoww);
316 free (dev->buffer);
317 free (dev);
321 dev->image_size = dev->buffer_size;
323 dev->image = malloc (dev->image_size);
324 if (dev->image == NULL)
326 free (dev->windowr);
327 free (dev->windoww);
328 free (dev->buffer);
329 free (dev->output);
330 free (dev);
342 stv680_close (Stv680_Vidcam * dev)
346 if (dev->fd != -1)
350 sanei_usb_close (dev->fd);
351 dev->fd = -1;
359 stv680_free (Stv680_Vidcam * dev)
365 if (dev == NULL)
368 stv680_close (dev);
369 if (dev->devicename)
371 free (dev->devicename);
373 if (dev->buffer)
375 free (dev->buffer);
377 if (dev->output)
379 free (dev->output);
381 if (dev->image)
383 free (dev->image);
385 if (dev->windoww)
387 free (dev->windoww);
389 if (dev->windowr)
391 free (dev->windowr);
395 if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s)
397 free (dev->val[i].s);
400 if (dev->resolutions_list)
401 free (dev->resolutions_list);
403 free (dev);
409 stv680_set_config (Stv680_Vidcam * dev, int configuration, int interface,
416 status = sanei_usb_set_configuration (dev->fd, configuration);
425 status = sanei_usb_claim_interface (dev->fd, interface);
433 status = sanei_usb_set_altinterface (dev->fd, alternate);
451 stv680_reset_vidcam (Stv680_Vidcam * dev)
459 sizew = dev->windoww_size;
460 sizer = dev->windowr_size;
462 memset (dev->windoww, 0, sizew);
463 memset (dev->windowr, 0, sizer);
467 sanei_usb_control_msg (dev->fd, 0x41, 0x0a, 0x0000, 0, sizew,
468 dev->windoww);
479 sanei_usb_control_msg (dev->fd, 0x41, 0x04, 0x0000, 0, sizew,
480 dev->windoww);
489 sanei_usb_control_msg (dev->fd, 0xc1, 0x80, 0x0000, 0, sizer,
490 dev->windowr);
496 dev->windowr[0], dev->windowr[1]);
504 dev->windowr, sizer);
508 status = stv680_set_config (dev, 1, 0, 0);
524 stv680_identify_vidcam (Stv680_Vidcam * dev)
534 status = sanei_usb_get_vendor_product (dev->fd, &vendor, &product);
545 dev->hw = &(vidcams[i]);
547 sizer = dev->windowr_size;
548 memset (dev->windowr, 0, sizer);
552 status = stv680_set_config (dev, 1, 0, 0);
562 sanei_usb_control_msg (dev->fd, 0xc1, 0x88, 0x5678, 0, sizer,
563 dev->windowr);
571 if ((dev->windowr[0] != 0x56) || (dev->windowr[1] != 0x78))
576 hexdump (DBG_info2, "urb12 window", dev->windowr, sizer);
580 hexdump (DBG_info2, "urb12 ping data", dev->windowr, sizer);
584 sanei_usb_control_msg (dev->fd, 0xc1, 0x85, 0x0000, 0, sizer,
585 dev->windowr);
589 hexdump (DBG_info2, "urbxx CMDID_GET_CAMERA_INFO", dev->windowr,
592 dev->SupportedModes = dev->windowr[7];
593 i = dev->SupportedModes;
594 dev->QSIF = 0;
595 dev->CIF = 0;
596 dev->QCIF = 0;
597 dev->VGA = 0;
598 dev->QVGA = 0;
600 dev->CIF = 1;
602 dev->VGA = 1;
604 dev->QVGA = 1;
606 dev->QCIF = 1;
607 dev->QSIF = dev->QVGA; /* for software subsample */
608 if (dev->SupportedModes == 0)
617 if (dev->VGA)
619 if (dev->CIF)
621 if (dev->QVGA)
623 if (dev->QCIF)
628 DBG (DBG_proc, "STV(i): Firmware rev is %i.%i\n", dev->windowr[0],
629 dev->windowr[1]);
630 DBG (DBG_proc, "STV(i): ASIC rev is %i.%i\n", dev->windowr[2],
631 dev->windowr[3]);
632 DBG (DBG_proc, "STV(i): Sensor ID is %i.%i\n", (dev->windowr[4]),
633 (dev->windowr[5]));
635 dev->HardwareConfig = dev->windowr[6];
636 i = dev->HardwareConfig;
674 sanei_usb_control_msg (dev->fd, 0xc1, 0x86, 0x0000, 0, sizer,
675 dev->windowr);
680 hexdump (DBG_info2, "urb25 CMDID_GET_IMAGE_INFO", dev->windowr,
683 ((dev->windowr[0] << 8) + (dev->windowr[1])));
687 ((dev->windowr[2] << 8) + (dev->windowr[3])));
689 ((dev->windowr[4] << 8) + (dev->windowr[5])));
691 ((dev->windowr[6] << 8) + (dev->windowr[7])));
693 ((dev->windowr[8] << 24) + (dev->windowr[9] << 16) +
694 (dev->windowr[10] << 8) + (dev->windowr[11])));
697 status = stv680_set_config (dev, 1, 0, 1);
716 stv680_vidcam_init (Stv680_Vidcam * dev)
725 sizew = dev->windoww_size;
726 sizer = dev->windowr_size;
728 memset (dev->windoww, 0, sizew);
729 memset (dev->windowr, 0, sizer);
732 dev->video_status = 0x04; /* dummy value busy */
734 while (dev->video_status == 0x04)
738 sanei_usb_control_msg (dev->fd, 0xc1, 0x8d, 0x0000, 0, sizer,
739 dev->windowr);
744 dev->windowr, sizer);
746 dev->video_status = dev->windowr[1];
747 if (dev->video_status == 0x02)
751 else if ((dev->video_status == 0x01) || (dev->video_status == 0x08))
754 dev->video_status);
756 else if (dev->video_status != 0x04)
761 sanei_usb_control_msg (dev->fd, 0x41, 0x04, 0x0000, 0, 0, 0);
771 if (dev->video_status == 0x01 || dev->video_status == 0x08)
776 sanei_usb_control_msg (dev->fd, 0xc1, 0x8a, 0x0000, 0, sizer,
777 dev->windowr);
781 val = dev->windowr[0];
783 dev->windowr, sizer);
784 if (dev->windowr[0] &= 0x00)
795 sanei_usb_control_msg (dev->fd, 0xc1, 0x8b, (i << 8), 0, sizer,
796 dev->windowr);
801 dev->windowr, sizer);
806 sanei_usb_control_msg (dev->fd, 0x80, 0x06, 0x0100, 0, sizer,
807 dev->windowr);
810 /* if (!(i > 0) && (dev->windowr[8] == 0x53) && (dev->windowr[9] == 0x05))
817 dev->windowr, sizer);
820 status = stv680_set_config (dev, 1, 0, 1);
832 sanei_usb_control_msg (dev->fd, 0x41, 0x09, dev->video_mode, 0, sizew,
833 dev->windoww);
837 dev->video_mode);
842 dev->video_mode);
844 if (dev->x_resolution == 176)
864 Stv680_Vidcam *dev;
874 for (dev = first_dev; dev; dev = dev->next)
876 if (strcmp (dev->sane.name, devicename) == 0)
880 *devp = dev;
888 dev = stv680_init ();
889 if (dev == NULL)
900 stv680_free (dev);
904 dev->devicename = strdup (devicename);
905 dev->fd = fd;
909 if (stv680_identify_vidcam (dev) == SANE_FALSE)
912 stv680_free (dev);
917 status = stv680_init_2 (dev);
924 stv680_close (dev);
931 if (dev->hw->color_adjust[0].resolution_x != 0)
937 while (dev->hw->color_adjust[num_entries].resolution_x != 0)
940 dev->resolutions_list = malloc (sizeof (SANE_Word) * (num_entries + 1));
942 if (dev->resolutions_list == NULL)
946 stv680_free (dev);
950 if (dev->CIF)
952 if (dev->VGA)
954 dev->resolutions_list[0] = num_entries;
958 dev->resolutions_list[i + 1 + dev->VGA + dev->QVGA] =
959 dev->hw->color_adjust[i].resolution_x;
964 dev->resolutions_list = NULL;
968 dev->sane.name = dev->devicename;
969 dev->sane.vendor = dev->hw->vendor_name;
970 dev->sane.model = dev->hw->product_name;
971 dev->sane.type = SANE_I18N ("webcam");
974 dev->next = first_dev;
975 first_dev = dev;
979 *devp = dev;
990 attach_one (const char *dev)
993 attach_vidcam (dev, NULL);
1000 stv680_init_options (Stv680_Vidcam * dev)
1007 memset (dev->opt, 0, sizeof (dev->opt));
1008 memset (dev->val, 0, sizeof (dev->val));
1012 dev->opt[i].size = sizeof (SANE_Word);
1013 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
1019 dev->opt[OPT_NUM_OPTS].name = "";
1020 dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
1021 dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
1022 dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
1023 dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
1024 dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
1027 dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
1028 dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
1029 dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
1030 dev->opt[OPT_MODE_GROUP].cap = 0;
1031 dev->opt[OPT_MODE_GROUP].size = 0;
1032 dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1035 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
1036 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
1037 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
1038 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
1039 dev->opt[OPT_MODE].size = max_string_size (scan_mode_list);
1040 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1041 dev->opt[OPT_MODE].constraint.string_list = scan_mode_list;
1042 dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */
1045 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
1046 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
1047 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
1048 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
1049 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
1050 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
1051 dev->val[OPT_RESOLUTION].w = dev->resolutions_list[dev->CIF + dev->QCIF + dev->VGA + dev->QVGA + dev->QSIF]; /* value will be 2 or 3 */
1054 dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
1055 dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
1056 dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
1057 dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
1058 dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
1059 dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
1060 dev->opt[OPT_BRIGHTNESS].constraint.range = &brightness_range;
1061 dev->val[OPT_BRIGHTNESS].w = 0; /* to get middle value */
1064 dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
1065 dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
1066 dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
1067 dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
1068 dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
1069 dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1072 dev->opt[OPT_WHITE_LEVEL_R].name = SANE_NAME_WHITE_LEVEL_R;
1073 dev->opt[OPT_WHITE_LEVEL_R].title = SANE_TITLE_WHITE_LEVEL_R;
1074 dev->opt[OPT_WHITE_LEVEL_R].desc = SANE_DESC_WHITE_LEVEL_R;
1075 dev->opt[OPT_WHITE_LEVEL_R].type = SANE_TYPE_INT;
1076 dev->opt[OPT_WHITE_LEVEL_R].unit = SANE_UNIT_NONE;
1077 dev->opt[OPT_WHITE_LEVEL_R].constraint_type = SANE_CONSTRAINT_RANGE;
1078 dev->opt[OPT_WHITE_LEVEL_R].constraint.range = &red_level_range;
1079 dev->val[OPT_WHITE_LEVEL_R].w = 00; /* to get middle value */
1082 dev->opt[OPT_WHITE_LEVEL_G].name = SANE_NAME_WHITE_LEVEL_G;
1083 dev->opt[OPT_WHITE_LEVEL_G].title = SANE_TITLE_WHITE_LEVEL_G;
1084 dev->opt[OPT_WHITE_LEVEL_G].desc = SANE_DESC_WHITE_LEVEL_G;
1085 dev->opt[OPT_WHITE_LEVEL_G].type = SANE_TYPE_INT;
1086 dev->opt[OPT_WHITE_LEVEL_G].unit = SANE_UNIT_NONE;
1087 dev->opt[OPT_WHITE_LEVEL_G].constraint_type = SANE_CONSTRAINT_RANGE;
1088 dev->opt[OPT_WHITE_LEVEL_G].constraint.range = &green_level_range;
1089 dev->val[OPT_WHITE_LEVEL_G].w = 00; /* to get middle value */
1092 dev->opt[OPT_WHITE_LEVEL_B].name = SANE_NAME_WHITE_LEVEL_B;
1093 dev->opt[OPT_WHITE_LEVEL_B].title = SANE_TITLE_WHITE_LEVEL_B;
1094 dev->opt[OPT_WHITE_LEVEL_B].desc = SANE_DESC_WHITE_LEVEL_B;
1095 dev->opt[OPT_WHITE_LEVEL_B].type = SANE_TYPE_INT;
1096 dev->opt[OPT_WHITE_LEVEL_B].unit = SANE_UNIT_NONE;
1097 dev->opt[OPT_WHITE_LEVEL_B].constraint_type = SANE_CONSTRAINT_RANGE;
1098 dev->opt[OPT_WHITE_LEVEL_B].constraint.range = &blue_level_range;
1099 dev->val[OPT_WHITE_LEVEL_B].w = 00; /* to get middle value */
1106 sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
1113 stv680_fill_image (Stv680_Vidcam * dev)
1119 assert (dev->image_begin == dev->image_end);
1120 assert (dev->real_bytes_left > 0);
1124 DBG (DBG_proc, "stv680_fill_image: real dev bytes left=0x%lx \n",
1125 (unsigned long) (size_t) dev->real_bytes_left);
1126 bulk_size_read = dev->real_bytes_left;
1128 while (dev->real_bytes_left)
1132 "stv680_fill_image: real dev bytes left, while loop=0x%lx \n",
1133 (unsigned long) (size_t) dev->real_bytes_left);
1135 size = dev->real_bytes_left;
1143 assert (dev->image_end != 0);
1150 "stv680_fill_image: dev->real_bytes_left: 0x%lx size: 0x%lx\n",
1151 (unsigned long) (size_t) dev->real_bytes_left, (unsigned long) (size_t) size);
1155 status = sanei_usb_read_bulk (dev->fd, dev->buffer, &size);
1164 (unsigned long) (size_t) size, (unsigned long) (size_t) dev->params.bytes_per_line);
1166 memcpy (dev->image + dev->image_end, dev->buffer, size);
1168 dev->image_end += size;
1170 if (dev->real_bytes_left > size)
1171 dev->real_bytes_left -= size;
1172 else if (dev->real_bytes_left <= size) /* last loop */
1173 dev->real_bytes_left = 0;
1175 (unsigned long) (size_t) dev->real_bytes_left);
1177 /* i = stv_sndctrl (0, dev, 0x80, 0, &window, 0x02); *//* Get Last Error */
1245 stv680_bayer_unshuffle (Stv680_Vidcam * dev, SANE_Byte * buf, size_t * size)
1251 int w = dev->cwidth;
1252 int vw = dev->x_resolution;
1253 int vh = dev->y_resolution;
1261 RED = dev->red_s;
1262 GREEN = dev->green_s;
1263 BLUE = dev->blue_s;
1282 p = dev->image[y * w + (x >> 1)];
1286 p = dev->image[y * w + (x >> 1) + (w >> 1)];
1309 *(dev->output + i + colour) = (SANE_Byte) p;
1319 if (dev->scan_mode == STV680_COLOR_RGB
1320 || dev->scan_mode == STV680_COLOR_RGB_TEXT)
1327 *(dev->output + i) = red_g[*(dev->output + i)];
1328 *(dev->output + i + 1) = green_g[*(dev->output + i + 1)];
1329 *(dev->output + i + 2) = blue_g[*(dev->output + i + 2)];
1335 if (dev->scan_mode != STV680_COLOR_RAW)
1352 *(dev->output + AD (x, y, vw) + BLUE) =
1353 ((int) *(dev->output + AD (x - 1, y, vw) + BLUE) +
1354 (int) *(dev->output + AD (x + 1, y, vw) + BLUE)) >> 1;
1355 *(dev->output + AD (x, y, vw) + RED) =
1356 ((int) *(dev->output + AD (x, y - 1, vw) + RED) +
1357 (int) *(dev->output + AD (x, y + 1, vw) + RED)) >> 1;
1361 *(dev->output + AD (x, y, vw) + GREEN) =
1362 ((int) *(dev->output + AD (x - 1, y, vw) + GREEN) +
1363 (int) *(dev->output + AD (x + 1, y, vw) + GREEN) +
1364 (int) *(dev->output + AD (x, y - 1, vw) + GREEN) +
1365 (int) *(dev->output + AD (x, y + 1, vw) + GREEN)) >> 2;
1366 *(dev->output + AD (x, y, vw) + RED) =
1367 ((int) *(dev->output + AD (x - 1, y - 1, vw) + RED) +
1368 (int) *(dev->output + AD (x - 1, y + 1, vw) + RED) +
1369 (int) *(dev->output + AD (x + 1, y - 1, vw) + RED) +
1370 (int) *(dev->output + AD (x + 1, y + 1, vw) + RED)) >> 2;
1374 *(dev->output + AD (x, y, vw) + GREEN) =
1375 ((int) *(dev->output + AD (x - 1, y, vw) + GREEN) +
1376 (int) *(dev->output + AD (x + 1, y, vw) + GREEN) +
1377 (int) *(dev->output + AD (x, y - 1, vw) + GREEN) +
1378 (int) *(dev->output + AD (x, y + 1, vw) + GREEN)) >> 2;
1379 *(dev->output + AD (x, y, vw) + BLUE) =
1380 ((int) *(dev->output + AD (x - 1, y - 1, vw) + BLUE) +
1381 (int) *(dev->output + AD (x + 1, y - 1, vw) + BLUE) +
1382 (int) *(dev->output + AD (x - 1, y + 1, vw) + BLUE) +
1383 (int) *(dev->output + AD (x + 1, y + 1, vw) +
1388 *(dev->output + AD (x, y, vw) + RED) =
1389 ((int) *(dev->output + AD (x - 1, y, vw) + RED) +
1390 (int) *(dev->output + AD (x + 1, y, vw) + RED)) >> 1;
1391 *(dev->output + AD (x, y, vw) + BLUE) =
1392 ((int) *(dev->output + AD (x, y - 1, vw) + BLUE) +
1393 (int) *(dev->output + AD (x, y + 1, vw) + BLUE)) >> 1;
1403 memcpy (dev->output, (dev->output + i), i);
1405 memcpy ((dev->output + (vh * i)), (dev->output + ((vh - 1) * i)), i);
1411 memcpy ((dev->output + i), (dev->output + i + 3), 3);
1412 memcpy ((dev->output + i + (vw * 3)),
1413 (dev->output + i + (vw - 1) * 3), 3);
1417 if (dev->subsample == 160)
1429 *(dev->output + i) = *(dev->output + p);
1430 *(dev->output + i + 1) = *(dev->output + p + 1);
1431 *(dev->output + i + 2) = *(dev->output + p + 2);
1442 if (dev->subsample == 160)
1452 bright_red = (dev->val[OPT_BRIGHTNESS].w) + (dev->val[OPT_WHITE_LEVEL_R].w);
1454 (dev->val[OPT_BRIGHTNESS].w) + (dev->val[OPT_WHITE_LEVEL_G].w);
1456 (dev->val[OPT_BRIGHTNESS].w) + (dev->val[OPT_WHITE_LEVEL_B].w);
1462 if ((*(dev->output + x) + bright_red) >= 255)
1465 else if ((*(dev->output + x) + bright_red) <= 0)
1468 *(buf + x) = (*(dev->output + x) + bright_red);
1470 if ((*(dev->output + y) + bright_green) >= 255)
1473 else if ((*(dev->output + y) + bright_green) <= 0)
1476 *(buf + y) = (*(dev->output + y) + bright_green);
1478 if ((*(dev->output + i) + bright_blue) >= 255)
1481 else if ((*(dev->output + i) + bright_blue) <= 0)
1484 *(buf + i) = (*(dev->output + i) + bright_blue);
1489 if (dev->scan_mode == STV680_COLOR_RGB_TEXT)
1491 strcpy (dev->picmsg_ps, "STVcam ");
1493 status = stv680_add_text (buf, vw, vh, dev->picmsg_ps);
1582 Stv680_Vidcam *dev;
1597 for (dev = first_dev; i < num_devices; dev = dev->next)
1598 devlist[i++] = &dev->sane;
1611 Stv680_Vidcam *dev;
1621 for (dev = first_dev; dev; dev = dev->next)
1623 if (strcmp (dev->sane.name, devicename) == 0)
1629 if (!dev)
1631 status = attach_vidcam (devicename, &dev);
1641 dev = first_dev; /* empty devicename -> use first device */
1644 if (!dev)
1651 stv680_init_options (dev);
1653 *handle = dev;
1663 Stv680_Vidcam *dev = handle;
1674 return dev->opt + option;
1681 Stv680_Vidcam *dev = handle;
1693 if (dev->scanning)
1703 cap = dev->opt[option].cap;
1721 *(SANE_Word *) val = dev->val[option].w;
1724 strcpy (val, dev->val[option].s);
1739 status = sanei_constrain_value (dev->opt + option, val, info);
1759 dev->val[option].w = *(SANE_Word *) val;
1764 if (strcmp (dev->val[option].s, val) == 0)
1767 free (dev->val[OPT_MODE].s);
1768 dev->val[OPT_MODE].s = (SANE_Char *) strdup (val);
1770 dev->opt[OPT_WHITE_LEVEL_R].cap &= ~SANE_CAP_INACTIVE;
1771 dev->opt[OPT_WHITE_LEVEL_G].cap &= ~SANE_CAP_INACTIVE;
1772 dev->opt[OPT_WHITE_LEVEL_B].cap &= ~SANE_CAP_INACTIVE;
1774 if (strcmp (dev->val[OPT_MODE].s, COLOR_RAW_STR) == 0)
1776 dev->scan_mode = STV680_COLOR_RAW;
1778 else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_STR) == 0)
1780 dev->scan_mode = STV680_COLOR_RGB;
1782 else if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR)
1785 dev->scan_mode = STV680_COLOR;
1788 else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_TEXT_STR) == 0)
1790 dev->scan_mode = STV680_COLOR_RGB_TEXT;
1797 dev->depth = 8;
1798 if (dev->resolutions_list != NULL)
1802 dev->opt[OPT_RESOLUTION].constraint_type =
1804 dev->opt[OPT_RESOLUTION].constraint.word_list =
1805 dev->resolutions_list;
1808 for (i = 1; i <= dev->resolutions_list[0]; i++)
1810 if (dev->resolutions_list[i] >= dev->val[OPT_RESOLUTION].w)
1813 if (i > dev->resolutions_list[0])
1816 dev->val[OPT_RESOLUTION].w = dev->resolutions_list[1];
1821 dev->val[OPT_RESOLUTION].w = dev->resolutions_list[i];
1845 Stv680_Vidcam *dev = handle;
1850 if (!(dev->scanning))
1852 dev->x_resolution = dev->val[OPT_RESOLUTION].w;
1854 memset (&dev->params, 0, sizeof (SANE_Parameters));
1856 dev->params.last_frame = SANE_TRUE;
1858 switch (dev->scan_mode)
1861 dev->bytes_pixel = 1; /* raw image is 422 code, 1 byte/pixel */
1866 dev->bytes_pixel = 3;
1869 dev->params.format = SANE_FRAME_RGB;
1870 dev->params.pixels_per_line = dev->x_resolution;
1871 dev->params.bytes_per_line =
1872 dev->params.pixels_per_line * dev->bytes_pixel;
1873 dev->params.depth = 8;
1874 if (dev->resolutions_list != NULL)
1881 dev->hw->color_adjust[i].resolution_x != dev->x_resolution;
1884 dev->red_s = dev->hw->color_adjust[i].z1_color_0;
1885 dev->green_s = dev->hw->color_adjust[i].z1_color_1;
1886 dev->blue_s = dev->hw->color_adjust[i].z1_color_2;
1887 dev->y_resolution = dev->hw->color_adjust[i].resolution_y;
1889 dev->subsample = 0;
1890 switch (dev->val[OPT_RESOLUTION].w)
1893 dev->video_mode = 0x0200;
1894 dev->cwidth = dev->x_resolution + 2;
1895 dev->cheight = dev->y_resolution + 2;
1898 dev->x_resolution = 320;
1899 dev->y_resolution = 240;
1900 dev->video_mode = 0x0300;
1901 dev->cwidth = dev->x_resolution + 2;
1902 dev->cheight = dev->y_resolution + 2;
1903 dev->subsample = 160;
1906 dev->video_mode = 0x0300;
1907 dev->cwidth = dev->x_resolution + 2;
1908 dev->cheight = dev->y_resolution + 2;
1911 dev->video_mode = 0x0000;
1912 dev->cwidth = dev->x_resolution + 4;
1913 dev->cheight = dev->y_resolution + 4;
1916 dev->video_mode = 0x0100;
1917 dev->cwidth = dev->x_resolution + 4;
1918 dev->cheight = dev->y_resolution + 4;
1921 dev->params.pixels_per_line = dev->x_resolution;
1922 dev->params.lines = dev->y_resolution;
1923 DBG (DBG_info, "sane_get_parameters: x=%d, y=%d\n", dev->x_resolution,
1924 dev->y_resolution);
1930 *params = (dev->params);
1941 Stv680_Vidcam *dev = handle;
1946 if (!(dev->scanning))
1948 sane_get_parameters (dev, NULL);
1951 if (sanei_usb_open (dev->devicename, &(dev->fd)) != 0)
1958 status = stv680_vidcam_init (dev);
1962 stv680_close (dev);
1968 dev->image_end = 0;
1969 dev->image_begin = 0;
1971 dev->real_bytes_left = dev->cwidth * dev->cheight;
1972 dev->bytes_left = dev->params.bytes_per_line * dev->params.lines;
1974 dev->scanning = SANE_TRUE;
1986 Stv680_Vidcam *dev = handle;
1992 if (dev->deliver_eof)
1994 dev->deliver_eof = 0;
1998 if (!(dev->scanning))
2001 stv680_reset_vidcam (dev);
2002 stv680_close (dev);
2003 dev->scanning = SANE_FALSE;
2007 if (dev->bytes_left <= 0)
2012 if (dev->image_begin == dev->image_end)
2015 status = stv680_fill_image (dev);
2024 if (dev->image_begin == dev->image_end)
2030 size = dev->bytes_left;
2036 if ((dev->image_end - dev->image_begin) > size)
2038 size = dev->image_end - dev->image_begin;
2039 DBG (DBG_proc, "sane_read: size < dev->image_end - dev->image_begin\n");
2041 /* diff between size an dev->bytes_left because of 356/352 and 292/288 */
2045 *len = dev->bytes_left; /* needed */
2046 size = dev->bytes_left;
2047 dev->bytes_left = 0; /* needed for frontend or ? */
2049 if (dev->scan_mode != STV680_COLOR_RAW)
2052 status = stv680_bayer_unshuffle (dev, buf, &size);
2062 memcpy (buf, dev->image, size);
2101 Stv680_Vidcam *dev = handle;
2106 if (dev->scanning == SANE_TRUE)
2109 stv680_reset_vidcam (dev);
2110 stv680_close (dev);
2112 dev->scanning = SANE_FALSE;
2113 dev->deliver_eof = 0;
2122 Stv680_Vidcam *dev = handle;
2129 if (dev->scanning == SANE_TRUE)
2131 stv680_reset_vidcam (dev);
2132 stv680_close (dev);
2134 dev->scanning = SANE_FALSE;
2136 /* Unlink dev. */
2137 if (first_dev == dev)
2139 first_dev = dev->next;
2144 while (dev_tmp->next && dev_tmp->next != dev)
2154 stv680_free (dev);