void timer::stop ()
{
if(!turn_on_m)return;
tick_type curclock = kernel_time();
duration += (curclock - start_stamp);
ARAGELI_ASSERT_1(is_calibrated());
absprec += delta;
turn_on_m = false;
}
static int
mp750_get_status (pixma_t * s, pixma_device_status_t * status)
{
int error;
error = query_status (s);
if (error < 0)
return error;
status->hardware = PIXMA_HARDWARE_OK;
status->adf = (has_paper (s)) ? PIXMA_ADF_OK : PIXMA_ADF_NO_PAPER;
status->cal =
(is_calibrated (s)) ? PIXMA_CALIBRATION_OK : PIXMA_CALIBRATION_OFF;
status->lamp = (is_warming_up (s)) ? PIXMA_LAMP_WARMING_UP : PIXMA_LAMP_OK;
return 0;
}
double timer::precision () const
{
tick_type tm = clock_time();
tick_type curabsprec = absprec;
if(turn_on_m)
{
ARAGELI_ASSERT_1(is_calibrated());
curabsprec += delta;
}
if(tm == 0)
if(curabsprec == 0)
return 0;
else
return std::numeric_limits<double>::max();
else
return double(curabsprec)/double(tm);
}
static int
mp750_fill_buffer (pixma_t * s, pixma_imagebuf_t * ib)
{
mp750_t *mp = (mp750_t *) s->subdriver;
int error;
uint8_t info;
unsigned block_size, bytes_received, n;
int shift[3], base_shift;
int c;
c = ((is_ccd_grayscale (s)) ? 3 : s->param->channels) * s->param->depth / 8; /* single-byte or double-byte data */
if (mp->state == state_warmup)
{
int tmo = 60;
query_status (s);
check_status (s);
/*SIM*/ while (!is_calibrated (s) && --tmo >= 0)
{
if (s->cancel)
return PIXMA_ECANCELED;
if (handle_interrupt (s, 1000) > 0)
{
block_size = 0;
error = request_image_block (s, &block_size, &info);
/*SIM*/ if (error < 0)
return error;
}
}
if (tmo < 0)
{
PDBG (pixma_dbg (1, "WARNING: Timed out waiting for calibration\n"));
return PIXMA_ETIMEDOUT;
}
pixma_sleep (100000);
query_status (s);
if (is_warming_up (s) || !is_calibrated (s))
{
PDBG (pixma_dbg (1, "WARNING: Wrong status: wup=%d cal=%d\n",
is_warming_up (s), is_calibrated (s)));
return PIXMA_EPROTO;
}
block_size = 0;
request_image_block (s, &block_size, &info);
/*SIM*/ mp->state = state_scanning;
mp->last_block = 0;
}
/* TODO: Move to other place, values are constant. */
base_shift = calc_component_shifting (s) * mp->line_size;
if (s->param->source == PIXMA_SOURCE_ADF)
{
shift[0] = 0;
shift[1] = -base_shift;
shift[2] = -2 * base_shift;
}
else
{
shift[0] = -2 * base_shift;
shift[1] = -base_shift;
shift[2] = 0;
}
do
{
if (mp->last_block_size > 0)
{
block_size = mp->imgbuf_len - mp->last_block_size;
memcpy (mp->img, mp->img + mp->last_block_size, block_size);
}
do
{
if (s->cancel)
return PIXMA_ECANCELED;
if (mp->last_block)
{
/* end of image */
info = mp->last_block;
if (info != 0x38)
{
query_status (s);
/*SIM*/ while ((info & 0x28) != 0x28)
{
pixma_sleep (10000);
error = request_image_block2 (s, &info);
if (s->cancel)
return PIXMA_ECANCELED; /* FIXME: Is it safe to cancel here? */
if (error < 0)
return error;
}
}
mp->needs_abort = (info != 0x38);
mp->last_block = info;
mp->state = state_finished;
return 0;
}
check_status (s);
/*SIM*/ while (handle_interrupt (s, 1) > 0);
/*SIM*/ block_size = IMAGE_BLOCK_SIZE;
error = request_image_block (s, &block_size, &info);
if (error < 0)
{
if (error == PIXMA_ECANCELED)
read_error_info (s, NULL, 0);
return error;
}
mp->last_block = info;
if ((info & ~0x38) != 0)
{
PDBG (pixma_dbg (1, "WARNING: Unknown info byte %x\n", info));
}
if (block_size == 0)
{
/* no image data at this moment. */
pixma_sleep (10000);
}
}
while (block_size == 0);
error = read_image_block (s, mp->rawimg + mp->rawimg_left);
if (error < 0)
{
mp->state = state_transfering;
return error;
}
bytes_received = error;
PASSERT (bytes_received == block_size);
/* TODO: simplify! */
mp->rawimg_left += bytes_received;
n = mp->rawimg_left / 3;
/* n = number of pixels in the buffer? */
/* Color to Grayscale converion for CCD sensor */
if (is_ccd_grayscale (s)) {
shift_rgb (mp->rawimg, n, shift[0], shift[1], shift[2], mp->stripe_shift, mp->line_size,
mp->imgcol + mp->imgbuf_ofs);
/* dst: img, src: imgcol */
rgb_to_gray (mp->img, mp->imgcol, n, c); /* cropping occurs later? */
PDBG (pixma_dbg (4, "*fill_buffer: did grayscale conversion \n"));
}
/* Color image processing */
else {
shift_rgb (mp->rawimg, n, shift[0], shift[1], shift[2], mp->stripe_shift, mp->line_size,
mp->img + mp->imgbuf_ofs);
PDBG (pixma_dbg (4, "*fill_buffer: no grayscale conversion---keep color \n"));
}
/* entering remaining unprocessed bytes after last complete pixel into mp->rawimg buffer -- no influence on mp->img */
n *= 3;
mp->shifted_bytes += n;
mp->rawimg_left -= n; /* rawimg_left = 0, 1 or 2 bytes left in the buffer. */
mp->last_block_size = n;
memcpy (mp->rawimg, mp->rawimg + n, mp->rawimg_left);
}
while (mp->shifted_bytes <= 0);
if ((unsigned) mp->shifted_bytes < mp->last_block_size)
{
if (is_ccd_grayscale (s))
ib->rptr = mp->img + mp->last_block_size/3 - mp->shifted_bytes/3; /* testing---works OK */
else
ib->rptr = mp->img + mp->last_block_size - mp->shifted_bytes;
}
else
ib->rptr = mp->img;
if (is_ccd_grayscale (s))
ib->rend = mp->img + mp->last_block_size/3; /* testing---works OK */
else
ib->rend = mp->img + mp->last_block_size;
return ib->rend - ib->rptr;
}
