inline void wildCopy16(UInt8 * dst, const UInt8 * src, UInt8 * dst_end)
{
    do
    {
        copy16(dst, src);
        dst += 16;
        src += 16;
    } while (dst < dst_end);
}
inline void wildCopy16(UInt8 * dst, const UInt8 * src, UInt8 * dst_end)
{
    /// Unrolling with clang is doing >10% performance degrade.
#if defined(__clang__)
    #pragma nounroll
#endif
    do
    {
        copy16(dst, src);
        dst += 16;
        src += 16;
    } while (dst < dst_end);
}
Beispiel #3
0
SANE_Status
kvs40xx_set_window (struct scanner * s, int wnd_id)
{
  struct window wnd;
  struct cmd c = {
    {0}, 10,
    NULL, 0,
    CMD_OUT
  };
  c.data = &wnd;
  c.data_size = sizeof (wnd);
  c.cmd[0] = SET_WINDOW;
  copy16 (c.cmd + 7, cpu2be16 (sizeof (wnd)));
  kvs40xx_init_window (s, &wnd, wnd_id);

  return send_command (s, &c);
}
Beispiel #4
0
SANE_Status
kvs40xx_set_timeout (struct scanner * s, int timeout)
{
  u16 t = cpu2be16 ((u16) timeout);
  struct cmd c = {
    {0}, 10,
    NULL, 0,
    CMD_OUT
  };
  c.data = &t;
  c.data_size = sizeof (t);
  c.cmd[0] = SET_TIMEOUT;
  c.cmd[2] = 0x8d;
  copy16 (c.cmd + 7, cpu2be16 (sizeof (t)));
  if (s->bus == USB)
    sanei_usb_set_timeout (timeout * 1000);

  return send_command (s, &c);
}
template <> void inline copy<16>(UInt8 * dst, const UInt8 * src) { copy16(dst, src); }
void
kvs40xx_init_window (struct scanner *s, struct window *wnd, int wnd_id)
{
  int paper = str_index (paper_list, s->val[PAPER_SIZE].s), i;
  memset (wnd, 0, sizeof (struct window));
  copy16 (wnd->window_descriptor_block_length, cpu2be16 (66));

  wnd->window_identifier = wnd_id;
  copy16 (wnd->x_resolution, cpu2be16 (s->val[RESOLUTION].w));
  copy16 (wnd->y_resolution, cpu2be16 (s->val[RESOLUTION].w));
  if (!paper)
    {
      copy32 (wnd->upper_left_x,
              cpu2be32 (mm2scanner_units (s->val[TL_X].w)));
      copy32 (wnd->upper_left_y,
              cpu2be32 (mm2scanner_units (s->val[TL_Y].w)));
      copy32 (wnd->document_width,
              cpu2be32 (mm2scanner_units (s->val[BR_X].w)));
      copy32 (wnd->width,
              cpu2be32 (mm2scanner_units (s->val[BR_X].w - s->val[TL_X].w)));
      copy32 (wnd->document_length, cpu2be32 (mm2scanner_units
                                              (s->val[BR_Y].w)));
      copy32 (wnd->length,
              cpu2be32 (mm2scanner_units (s->val[BR_Y].w - s->val[TL_Y].w)));
    }
  else
    {
      u32 w = cpu2be32 (mm2scanner_units (paper_sizes[paper].width));
      u32 h = cpu2be32 (mm2scanner_units (paper_sizes[paper].height));
      copy32 (wnd->upper_left_x, cpu2be32 (mm2scanner_units (0)));
      copy32 (wnd->upper_left_y, cpu2be32 (mm2scanner_units (0)));
      if (!s->val[LANDSCAPE].b)
	{
	  copy32 (wnd->width, w);
	  copy32 (wnd->length, h);
	  copy32 (wnd->document_width, w);
	  copy32 (wnd->document_length, h);
	}
      else
	{
	  copy32 (wnd->width, h);
	  copy32 (wnd->length, w);
	  copy32 (wnd->document_width, h);
	  copy32 (wnd->document_length, w);
	}
    }
  wnd->brightness = s->val[BRIGHTNESS].w;
  wnd->threshold = s->val[THRESHOLD].w;
  wnd->contrast = s->val[CONTRAST].w;
  wnd->image_composition = mode_val[str_index (mode_list, s->val[MODE].s)];
  wnd->bit_per_pixel = bps_val[str_index (mode_list, s->val[MODE].s)];

  copy16 (wnd->halftone_pattern,
          cpu2be16 (str_index (halftone_pattern, s->val[HALFTONE_PATTERN].s)));

  wnd->rif_padding = s->val[INVERSE].b << 7;
  copy16 (wnd->bit_ordering, cpu2be16 (BIT_ORDERING));
  wnd->compression_type = s->val[COMPRESSION].b ? 0x81 : 0;
  wnd->compression_argument = s->val[COMPRESSION_PAR].w;

  wnd->vendor_unique_identifier = 0;
  wnd->nobuf_fstspeed_dfstop = str_index (source_list,
					  s->val[SOURCE].s) << 7 |
    str_index (stapeled_list,
	       s->val[STAPELED_DOC].s) << 5 |
    s->val[STOP_SKEW].b << 4 | s->val[CROP].b << 3 | s->val[DFSTOP].b << 0;

  wnd->mirror_image = s->val[MIRROR].b << 7 |
    s->val[DFEED_L].b << 2 | s->val[DFEED_C].b << 1 | s->val[DFEED_R].b << 0;
  wnd->image_emphasis = str_index (image_emphasis_list,
				   s->val[IMAGE_EMPHASIS].s);
  wnd->gamma_correction = gamma_val[str_index (gamma_list,
					       s->val[GAMMA_CORRECTION].s)];
  wnd->mcd_lamp_dfeed_sens =
    str_index (lamp_list, s->val[LAMP].s) << 4 |
    str_index (dfeed_sence_list, s->val[DFEED_SENCE].s);

  wnd->document_size = (paper != 0) << 7
    | s->val[LENGTHCTL].b << 6
    | s->val[LONG_PAPER].b << 5 | s->val[LANDSCAPE].b << 4 | paper_val[paper];

  wnd->ahead_deskew_dfeed_scan_area_fspeed_rshad =
    (s->val[DESKEW].b || s->val[CROP].b ? 2 : 0) << 5 | /*XXX*/
    s->val[DBLFEED].b << 4 | s->val[FIT_TO_PAGE].b << 2;
  wnd->continuous_scanning_pages =
    str_index (feeder_mode_list, s->val[FEEDER_MODE].s) ? 0xff : 0;
  wnd->automatic_threshold_mode = automatic_threshold_val
    [str_index (automatic_threshold_list, s->val[AUTOMATIC_THRESHOLD].s)];
  wnd->automatic_separation_mode = 0;	/*Does not supported */
  wnd->standard_white_level_mode =
    white_level_val[str_index (white_level_list, s->val[WHITE_LEVEL].s)];
  wnd->b_wnr_noise_reduction =
    str_index (noise_reduction_list, s->val[NOISE_REDUCTION].s);

  i = str_index (manual_feed_list, s->val[MANUALFEED].s);
  wnd->mfeed_toppos_btmpos_dsepa_hsepa_dcont_rstkr = i << 6 |
    s->val[TOPPOS].b << 5 | s->val[BTMPOS].b << 4;
  wnd->stop_mode = 1;
  wnd->red_chroma = s->val[RED_CHROMA].w;
  wnd->blue_chroma = s->val[BLUE_CHROMA].w;
}