Lines Matching defs:dev
3 Copyright (C) 2010-2013 Stéphane Voltz <stef.dev@free.fr>
109 void sanei_genesys_set_buffer_address(Genesys_Device* dev, std::uint32_t addr)
113 if (dev->model->asic_type==AsicType::GL847 ||
114 dev->model->asic_type==AsicType::GL845 ||
115 dev->model->asic_type==AsicType::GL846 ||
116 dev->model->asic_type==AsicType::GL124)
126 dev->interface->write_register(0x2b, (addr & 0xff));
129 dev->interface->write_register(0x2a, (addr & 0xff));
136 Status scanner_read_status(Genesys_Device& dev)
141 switch (dev.model->asic_type) {
163 auto value = dev.interface->read_register(address);
181 Status scanner_read_reliable_status(Genesys_Device& dev)
185 scanner_read_status(dev);
186 dev.interface->sleep_ms(100);
187 return scanner_read_status(dev);
190 void scanner_read_print_status(Genesys_Device& dev)
192 scanner_read_status(dev);
206 void scanner_register_rw_clear_bits(Genesys_Device& dev, std::uint16_t address, std::uint8_t mask)
208 scanner_register_rw_bits(dev, address, 0x00, mask);
211 void scanner_register_rw_set_bits(Genesys_Device& dev, std::uint16_t address, std::uint8_t mask)
213 scanner_register_rw_bits(dev, address, mask, mask);
216 void scanner_register_rw_bits(Genesys_Device& dev, std::uint16_t address,
219 auto reg_value = dev.interface->read_register(address);
221 dev.interface->write_register(address, reg_value);
228 void sanei_genesys_read_valid_words(Genesys_Device* dev, unsigned int* words)
232 switch (dev->model->asic_type)
235 *words = dev->interface->read_register(0x102) & 0x03;
236 *words = *words * 256 + dev->interface->read_register(0x103);
237 *words = *words * 256 + dev->interface->read_register(0x104);
238 *words = *words * 256 + dev->interface->read_register(0x105);
243 *words = dev->interface->read_register(0x42) & 0x02;
244 *words = *words * 256 + dev->interface->read_register(0x43);
245 *words = *words * 256 + dev->interface->read_register(0x44);
246 *words = *words * 256 + dev->interface->read_register(0x45);
250 *words = dev->interface->read_register(0x42) & 0x03;
251 *words = *words * 256 + dev->interface->read_register(0x43);
252 *words = *words * 256 + dev->interface->read_register(0x44);
253 *words = *words * 256 + dev->interface->read_register(0x45);
257 *words = dev->interface->read_register(0x44);
258 *words += dev->interface->read_register(0x43) * 256;
259 if (dev->model->asic_type == AsicType::GL646) {
260 *words += ((dev->interface->read_register(0x42) & 0x03) * 256 * 256);
262 *words += ((dev->interface->read_register(0x42) & 0x0f) * 256 * 256);
272 void sanei_genesys_read_scancnt(Genesys_Device* dev, unsigned int* words)
276 if (dev->model->asic_type == AsicType::GL124) {
277 *words = (dev->interface->read_register(0x10b) & 0x0f) << 16;
278 *words += (dev->interface->read_register(0x10c) << 8);
279 *words += dev->interface->read_register(0x10d);
283 *words = dev->interface->read_register(0x4d);
284 *words += dev->interface->read_register(0x4c) * 256;
285 if (dev->model->asic_type == AsicType::GL646) {
286 *words += ((dev->interface->read_register(0x4b) & 0x03) * 256 * 256);
288 *words += ((dev->interface->read_register(0x4b) & 0x0f) * 256 * 256);
296 * @param *dev device to test for data
300 bool sanei_genesys_is_buffer_empty(Genesys_Device* dev)
304 dev->interface->sleep_ms(1);
306 auto status = scanner_read_status(*dev);
312 dev->interface->sleep_ms(1);
322 void wait_until_buffer_non_empty(Genesys_Device* dev, bool check_status_twice)
330 scanner_read_status(*dev);
333 bool empty = sanei_genesys_is_buffer_empty(dev);
334 dev->interface->sleep_ms(10);
341 void wait_until_has_valid_words(Genesys_Device* dev)
347 sanei_genesys_read_valid_words(dev, &words);
350 dev->interface->sleep_ms(sleep_time_ms);
359 void sanei_genesys_read_data_from_scanner(Genesys_Device* dev, std::uint8_t* data, size_t size)
366 wait_until_has_valid_words(dev);
368 dev->interface->bulk_read_data(0x45, data, size);
371 Image read_unshuffled_image_from_scanner(Genesys_Device* dev, const ScanSession& session,
377 dev->model->is_cis ? 1 : session.params.channels,
378 dev->model->line_mode_color_order);
394 sanei_genesys_read_data_from_scanner(dev, image.get_row_ptr(0), total_bytes);
401 pipeline.push_node<ImagePipelineNodeDesegment>(output_width, dev->segment_order,
408 if (has_flag(dev->model->flags, ModelFlag::SWAP_16BIT_DATA)) {
415 dev->pipeline.push_node<ImagePipelineNodeSwap16BitEndian>();
419 if (has_flag(dev->model->flags, ModelFlag::INVERT_PIXEL_DATA)) {
423 if (dev->model->is_cis && session.params.channels == 3) {
424 pipeline.push_node<ImagePipelineNodeMergeMonoLinesToColor>(dev->model->line_mode_color_order);
443 Image read_shuffled_image_from_scanner(Genesys_Device* dev, const ScanSession& session)
450 if (dev->model->asic_type == AsicType::GL842 ||
451 dev->model->asic_type == AsicType::GL843 ||
452 dev->model->model_id == ModelId::CANON_5600F)
462 if (dev->model->asic_type == AsicType::GL842 ||
463 dev->model->asic_type == AsicType::GL843 ||
464 dev->model->model_id == ModelId::CANON_5600F)
472 dev->model->is_cis ? 1 : session.params.channels,
473 dev->model->line_mode_color_order);
478 if (dev->model->asic_type == AsicType::GL842 ||
479 dev->model->asic_type == AsicType::GL843 ||
480 dev->model->model_id == ModelId::CANON_5600F)
496 sanei_genesys_read_data_from_scanner(dev, image.get_row_ptr(0), total_bytes);
503 pipeline.push_node<ImagePipelineNodeDesegment>(output_width, dev->segment_order,
510 if (has_flag(dev->model->flags, ModelFlag::SWAP_16BIT_DATA)) {
517 dev->pipeline.push_node<ImagePipelineNodeSwap16BitEndian>();
521 if (has_flag(dev->model->flags, ModelFlag::INVERT_PIXEL_DATA)) {
525 if (dev->model->is_cis && session.params.channels == 3) {
526 pipeline.push_node<ImagePipelineNodeMergeMonoLinesToColor>(dev->model->line_mode_color_order);
540 void sanei_genesys_read_feed_steps(Genesys_Device* dev, unsigned int* steps)
544 if (dev->model->asic_type == AsicType::GL124) {
545 *steps = (dev->interface->read_register(0x108) & 0x1f) << 16;
546 *steps += (dev->interface->read_register(0x109) << 8);
547 *steps += dev->interface->read_register(0x10a);
551 *steps = dev->interface->read_register(0x4a);
552 *steps += dev->interface->read_register(0x49) * 256;
553 if (dev->model->asic_type == AsicType::GL646) {
554 *steps += ((dev->interface->read_register(0x48) & 0x03) * 256 * 256);
555 } else if (dev->model->asic_type == AsicType::GL841) {
556 *steps += ((dev->interface->read_register(0x48) & 0x0f) * 256 * 256);
558 *steps += ((dev->interface->read_register(0x48) & 0x1f) * 256 * 256);
565 void sanei_genesys_set_lamp_power(Genesys_Device* dev, const Genesys_Sensor& sensor,
573 if (dev->model->asic_type == AsicType::GL841) {
574 regs_set_exposure(dev->model->asic_type, regs,
579 if (dev->model->asic_type == AsicType::GL843) {
580 regs_set_exposure(dev->model->asic_type, regs, sensor.exposure);
584 if ((dev->model->model_id == ModelId::CANON_8400F ||
585 dev->model->model_id == ModelId::CANON_8600F ||
586 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7200I ||
587 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7500I ||
588 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_8200I) &&
589 dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
596 if (dev->model->asic_type == AsicType::GL841) {
597 regs_set_exposure(dev->model->asic_type, regs, sanei_genesys_fixup_exposure({0, 0, 0}));
600 if (dev->model->model_id == ModelId::CANON_5600F) {
601 regs_set_exposure(dev->model->asic_type, regs, sanei_genesys_fixup_exposure({0, 0, 0}));
638 std::vector<std::uint16_t> get_gamma_table(Genesys_Device* dev, const Genesys_Sensor& sensor,
641 if (!dev->gamma_override_tables[color].empty()) {
642 return dev->gamma_override_tables[color];
645 sanei_genesys_create_default_gamma_table(dev, ret, sensor.gamma[color]);
653 * @param dev device to set up
658 std::vector<std::uint8_t> generate_gamma_buffer(Genesys_Device* dev,
667 std::vector<std::uint16_t> rgamma = get_gamma_table(dev, sensor, GENESYS_RED);
668 std::vector<std::uint16_t> ggamma = get_gamma_table(dev, sensor, GENESYS_GREEN);
669 std::vector<std::uint16_t> bgamma = get_gamma_table(dev, sensor, GENESYS_BLUE);
686 if(dev->settings.contrast!=0 || dev->settings.brightness!=0)
694 dev->settings.contrast,
695 dev->settings.brightness);
720 * @param dev device to write to
722 void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& sensor)
730 auto gamma = generate_gamma_buffer(dev, sensor, 16, 65535, size);
735 std::uint8_t val = dev->interface->read_register(0xbd);
737 dev->interface->write_register(0xbd, val);
740 val = dev->interface->read_register(0xbe);
742 dev->interface->write_register(0xbe, val);
751 dev->interface->write_register(0xc5+2*i, gamma[size*2*i+1]);
752 dev->interface->write_register(0xc6+2*i, gamma[size*2*i]);
754 dev->interface->write_ahb(0x01000000 + 0x200 * i, (size-1) * 2,
759 void compute_session_pixel_offsets(const Genesys_Device* dev, ScanSession& s,
762 if (dev->model->asic_type == AsicType::GL646) {
766 } else if (dev->model->asic_type == AsicType::GL841 ||
767 dev->model->asic_type == AsicType::GL842 ||
768 dev->model->asic_type == AsicType::GL843 ||
769 dev->model->asic_type == AsicType::GL845 ||
770 dev->model->asic_type == AsicType::GL846 ||
771 dev->model->asic_type == AsicType::GL847)
774 if (dev->model->model_id == ModelId::CANON_5600F ||
775 dev->model->model_id == ModelId::CANON_LIDE_90)
787 } else if (dev->model->asic_type == AsicType::GL124)
802 if (dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7200 ||
803 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7200I ||
804 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7300 ||
805 dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7500I)
813 const Genesys_Device& dev, const Genesys_Sensor& sensor,
818 if (dev.model->model_id == ModelId::CANON_5600F) {
828 if (dev.model->asic_type == AsicType::GL841 ||
829 dev.model->asic_type == AsicType::GL842)
834 if (dev.model->asic_type == AsicType::GL646 && output_xresolution == 400) {
838 if (dev.model->asic_type == AsicType::GL843) {
843 if (dev.model->model_id == ModelId::PLUSTEK_OPTICFILM_7200 ||
844 dev.model->model_id == ModelId::PLUSTEK_OPTICFILM_7200I ||
845 dev.model->model_id == ModelId::PLUSTEK_OPTICFILM_7300 ||
846 dev.model->model_id == ModelId::PLUSTEK_OPTICFILM_7400 ||
847 dev.model->model_id == ModelId::PLUSTEK_OPTICFILM_7500I ||
848 dev.model->model_id == ModelId::PLUSTEK_OPTICFILM_8200I)
861 if (has_flag(dev.model->flags, ModelFlag::SIS_SENSOR) ||
862 dev.model->asic_type == AsicType::GL847 ||
863 dev.model->asic_type == AsicType::GL124 ||
864 dev.model->asic_type == AsicType::GL845 ||
865 dev.model->asic_type == AsicType::GL846 ||
866 dev.model->asic_type == AsicType::GL843)
882 dev.model->asic_type == AsicType::GL124 ||
883 dev.model->asic_type == AsicType::GL847 ||
884 dev.session.params.xres < dev.session.params.yres))
899 void compute_session(const Genesys_Device* dev, ScanSession& s, const Genesys_Sensor& sensor)
903 (void) dev;
921 s.output_pixels = session_adjust_output_pixels(s.params.pixels, *dev, sensor,
934 if (has_flag(dev->model->flags, ModelFlag::HOST_SIDE_GRAY) && s.params.channels == 1 &&
950 s.color_shift_lines_r = dev->model->ld_shift_r;
951 s.color_shift_lines_g = dev->model->ld_shift_g;
952 s.color_shift_lines_b = dev->model->ld_shift_b;
954 if (dev->model->motor_id == MotorId::G4050 && s.params.yres > 600) {
956 s.color_shift_lines_r = (s.color_shift_lines_r * 3800) / dev->motor.base_ydpi;
957 s.color_shift_lines_g = (s.color_shift_lines_g * 3800) / dev->motor.base_ydpi;
958 s.color_shift_lines_b = (s.color_shift_lines_b * 3800) / dev->motor.base_ydpi;
961 s.color_shift_lines_r = (s.color_shift_lines_r * s.params.yres) / dev->motor.base_ydpi;
962 s.color_shift_lines_g = (s.color_shift_lines_g * s.params.yres) / dev->motor.base_ydpi;
963 s.color_shift_lines_b = (s.color_shift_lines_b * s.params.yres) / dev->motor.base_ydpi;
972 s.optical_line_count = dev->model->is_cis ? s.output_line_count * s.params.channels
985 if ((dev->model->asic_type == AsicType::GL845 ||
986 dev->model->asic_type == AsicType::GL846 ||
987 dev->model->asic_type == AsicType::GL847) &&
988 dev->model->model_id != ModelId::PLUSTEK_OPTICFILM_7400 &&
989 dev->model->model_id != ModelId::PLUSTEK_OPTICFILM_8200I)
995 if (dev->model->model_id == ModelId::CANON_5600F) {
997 if (dev->model->model_id == ModelId::CANON_5600F) {
1026 if (dev->model->model_id == ModelId::CANON_5600F) {
1037 if (dev->model->asic_type == AsicType::GL841 ||
1038 dev->model->asic_type == AsicType::GL842)
1040 if (dev->model->is_cis) {
1045 if (dev->model->asic_type == AsicType::GL124) {
1046 if (dev->model->is_cis) {
1052 if (dev->model->asic_type == AsicType::GL842 ||
1053 dev->model->asic_type == AsicType::GL843)
1055 if (dev->model->is_cis) {
1065 if (dev->model->asic_type == AsicType::GL124 ||
1066 dev->model->asic_type == AsicType::GL842 ||
1067 dev->model->asic_type == AsicType::GL843)
1073 if (dev->model->model_id == ModelId::CANON_LIDE_90) {
1077 if (dev->model->asic_type == AsicType::GL845 ||
1078 dev->model->asic_type == AsicType::GL846 ||
1079 dev->model->asic_type == AsicType::GL847)
1081 if (dev->model->model_id == ModelId::CANON_5600F) {
1093 if (dev->model->model_id == ModelId::CANON_LIDE_90) {
1099 compute_session_pixel_offsets(dev, s, sensor);
1103 if (dev->model->asic_type == AsicType::GL124 ||
1104 dev->model->asic_type == AsicType::GL845 ||
1105 dev->model->asic_type == AsicType::GL846)
1107 s.enable_ledadd = (s.params.channels == 1 && dev->model->is_cis &&
1113 if (dev->model->asic_type == AsicType::GL841 ||
1114 dev->model->asic_type == AsicType::GL842 ||
1115 dev->model->asic_type == AsicType::GL843)
1129 ImagePipelineStack build_image_pipeline(const Genesys_Device& dev, const ScanSession& session,
1133 dev.model->is_cis ? 1 : session.params.channels,
1134 dev.model->line_mode_color_order);
1138 auto read_data_from_usb = [&dev](std::size_t size, std::uint8_t* data)
1142 dev.interface->bulk_read_data(0x45, data, size);
1171 pipeline.push_node<ImagePipelineNodeDesegment>(output_width, dev.segment_order,
1182 if (has_flag(dev.model->flags, ModelFlag::SWAP_16BIT_DATA)) {
1197 if (has_flag(dev.model->flags, ModelFlag::INVERT_PIXEL_DATA)) {
1205 if (dev.model->is_cis && session.params.channels == 3) {
1206 pipeline.push_node<ImagePipelineNodeMergeMonoLinesToColor>(dev.model->line_mode_color_order);
1255 !has_flag(dev.model->flags, ModelFlag::DISABLE_SHADING_CALIBRATION) &&
1258 unsigned offset_pixels = session.params.startx + dev.calib_session.shading_pixel_offset;
1259 unsigned offset_bytes = offset_pixels * dev.calib_session.params.channels;
1260 pipeline.push_node<ImagePipelineNodeCalibrate>(dev.dark_average_data,
1261 dev.white_average_data, offset_bytes);
1283 void setup_image_pipeline(Genesys_Device& dev, const ScanSession& session)
1289 dev.pipeline = build_image_pipeline(dev, session, s_pipeline_index, dbg_log_image_data());
1291 auto read_from_pipeline = [&dev](std::size_t size, std::uint8_t* out_data)
1293 (void) size; // will be always equal to dev.pipeline.get_output_row_bytes()
1294 return dev.pipeline.get_next_row_data(out_data);
1296 dev.pipeline_buffer = ImageBuffer{dev.pipeline.get_output_row_bytes(),
1400 * @param dev device to initialize
1403 void sanei_genesys_asic_init(Genesys_Device* dev)
1411 dev->interface->get_usb_device().control_msg(REQUEST_TYPE_IN, REQUEST_REGISTER,
1418 dev->usb_mode = 1;
1422 dev->usb_mode = 2;
1430 if (dev->interface->read_register(0x06) & 0x10) {
1438 if (dev->already_initialized && !cold)
1445 dev->cmd_set->asic_boot(dev, cold);
1448 dev->white_average_data.clear();
1449 dev->dark_average_data.clear();
1451 dev->settings.color_filter = ColorFilter::RED;
1453 dev->initial_regs = dev->reg;
1455 const auto& sensor = sanei_genesys_find_sensor_any(dev);
1458 dev->cmd_set->set_fe(dev, sensor, AFE_INIT);
1460 dev->already_initialized = true;
1463 if (dev->model->model_id == ModelId::CANON_8600F) {
1464 if (!dev->cmd_set->is_head_home(*dev, ScanHeadId::SECONDARY)) {
1465 dev->set_head_pos_unknown(ScanHeadId::SECONDARY);
1467 if (!dev->cmd_set->is_head_home(*dev, ScanHeadId::PRIMARY)) {
1468 dev->set_head_pos_unknown(ScanHeadId::SECONDARY);
1471 dev->cmd_set->move_back_home(dev, true);
1474 dev->cmd_set->set_powersaving(dev, 15);
1477 void scanner_start_action(Genesys_Device& dev, bool start_motor)
1480 switch (dev.model->asic_type) {
1495 dev.interface->write_register(0x0f, 0x01);
1497 dev.interface->write_register(0x0f, 0);
1646 void sanei_genesys_wait_for_home(Genesys_Device* dev)
1651 dev->parking = false;
1659 auto status = scanner_read_status(*dev);
1660 dev->interface->sleep_ms(10);
1661 status = scanner_read_status(*dev);
1673 dev->interface->sleep_ms(100);
1676 status = scanner_read_status(*dev);
1763 * @param dev device description
1766 int sanei_genesys_get_lowest_ydpi(Genesys_Device *dev)
1768 const auto& resolution_settings = dev->model->get_resolution_settings(dev->settings.scan_method);
1774 * @param dev device description
1777 int sanei_genesys_get_lowest_dpi(Genesys_Device *dev)
1779 const auto& resolution_settings = dev->model->get_resolution_settings(dev->settings.scan_method);
1792 bool sanei_genesys_is_compatible_calibration(Genesys_Device* dev,
1856 if (!for_overwrite && dev->settings.expiration_time >=0)
1859 if ((time.tv_sec - cache->last_calibration > dev->settings.expiration_time*60)
1860 && !dev->model->is_sheetfed
1861 && (dev->settings.scan_method == ScanMethod::FLATBED))