1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
/* SANE - Scanner Access Now Easy.
Copyright (C) 2011-2019 Rolf Bensch <rolf at bensch hyphen online dot de>
Copyright (C) 2006-2007 Wittawat Yamwong <wittawat@web.de>
This file is part of the SANE package.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.
As a special exception, the authors of SANE give permission for
additional uses of the libraries contained in this release of SANE.
The exception is that, if you link a SANE library with other files
to produce an executable, this does not by itself cause the
resulting executable to be covered by the GNU General Public
License. Your use of that executable is in no way restricted on
account of linking the SANE library code into it.
This exception does not, however, invalidate any other reasons why
the executable file might be covered by the GNU General Public
License.
If you submit changes to SANE to the maintainers to be included in
a subsequent release, you agree by submitting the changes that
those changes may be distributed with this exception intact.
If you write modifications of your own for SANE, it is your choice
whether to permit this exception to apply to your modifications.
If you do not wish that, delete this exception notice.
*/
#ifndef PIXMA_COMMON_H
#define PIXMA_COMMON_H
#include <time.h> /* time_t */
#include "pixma.h"
/*! \defgroup subdriver Subdriver Interface
* \brief Subdriver interface. */
/*! \defgroup debug Debug utilities
* \brief Debug utilities. */
#ifdef NDEBUG
# define PDBG(x) do {} while(0)
# define PASSERT(x) do {} while(0)
#else
# define PDBG(x) x
# define PASSERT(x) do { \
if (!(x)) \
pixma_dbg(1, "ASSERT failed:%s:%d: " \
#x "\n", __FILE__, __LINE__); \
} while(0)
#endif
#define PIXMA_STATUS_OK 0x0606
#define PIXMA_STATUS_FAILED 0x1515
#define PIXMA_STATUS_BUSY 0x1414
#define PIXMA_MAX_ID_LEN 30
/* These may have been defined elsewhere */
#ifndef MIN
#define MIN(x,y) (((x) < (y)) ? (x):(y))
#endif
#ifndef MAX
#define MAX(x,y) (((x) < (y)) ? (y):(x))
#endif
#define ALIGN_SUP(x,n) (((x) + (n) - 1) / (n) * (n))
#define ALIGN_INF(x,n) (((x) / (n)) * (n))
struct pixma_io_t;
struct pixma_limits_t
{
unsigned xdpi, ydpi;
unsigned width, height;
};
struct pixma_cmdbuf_t
{
unsigned cmd_header_len, res_header_len, cmd_len_field_ofs;
unsigned expected_reslen, cmdlen;
int reslen;
unsigned size;
uint8_t *buf;
};
struct pixma_imagebuf_t
{
uint8_t *wptr, *wend;
const uint8_t *rptr, *rend;
};
struct pixma_t
{
pixma_t *next;
struct pixma_io_t *io;
const pixma_scan_ops_t *ops;
pixma_scan_param_t *param;
const pixma_config_t *cfg;
char id[PIXMA_MAX_ID_LEN + 1];
int cancel; /* NOTE: It can be set in a signal handler. */
uint32_t events;
void *subdriver; /* can be used by model driver. */
int rec_tmo; /* receive timeout [s] */
/* private */
uint64_t cur_image_size;
pixma_imagebuf_t imagebuf;
unsigned scanning:1;
unsigned underrun:1;
};
/** \addtogroup subdriver
* @{ */
/** Scan operations for subdriver. */
struct pixma_scan_ops_t
{
/** Allocate a data structure for the subdriver. It is called after the
* core driver connected to the scanner. The subdriver should reset the
* scanner to a known state in this function. */
int (*open) (pixma_t *);
/** Free resources allocated by the subdriver. Don't forget to send abort
* command to the scanner if it is scanning. */
void (*close) (pixma_t *);
/** Setup the scanner for scan parameters defined in \a s->param. */
int (*scan) (pixma_t * s);
/** Fill a buffer with image data. The subdriver has two choices:
* -# Fill the buffer pointed by ib->wptr directly and leave
* ib->rptr and ib->rend untouched. The length of the buffer is
* ib->wend - ib->wptr. It must update ib->wptr accordingly.
* -# Update ib->rptr and ib->rend to point to the beginning and
* the end of the internal buffer resp. The length of the buffer
* is ib->rend - ib->rptr. This function is called again if
* and only if pixma_read_image() has copied the whole buffer.
*
* The subdriver must wait until there is at least one byte to read or
* return 0 for the end of image. */
int (*fill_buffer) (pixma_t *, pixma_imagebuf_t * ib);
/** Cancel the scan operation if necessary and free resources allocated in
* scan(). */
void (*finish_scan) (pixma_t *);
/** [Optional] Wait for a user's event, e.g. button event. \a timeout is
* in milliseconds. If an event occured before it's timed out, flags in
* \a s->events should be set accordingly.
* \see PIXMA_EV_* */
void (*wait_event) (pixma_t * s, int timeout);
/** Check the scan parameters. The parameters can be adjusted if they are
* out of range, e.g. width > max_width. */
int (*check_param) (pixma_t *, pixma_scan_param_t *);
/** Read the device status. \see pixma_get_device_status() */
int (*get_status) (pixma_t *, pixma_device_status_t *);
};
/** \name Funtions for read and write big-endian integer values */
/**@{*/
void pixma_set_be16 (uint16_t x, uint8_t * buf);
void pixma_set_be32 (uint32_t x, uint8_t * buf);
uint16_t pixma_get_be16 (const uint8_t * buf);
uint32_t pixma_get_be32 (const uint8_t * buf);
/**@}*/
/** \name Utility functions */
/**@{*/
uint8_t pixma_sum_bytes (const void *data, unsigned len);
int pixma_check_dpi (unsigned dpi, unsigned max);
void pixma_sleep (unsigned long usec);
void pixma_get_time (time_t * sec, uint32_t * usec);
uint8_t * pixma_r_to_ir (uint8_t * gptr, uint8_t * sptr, unsigned w, unsigned c);
uint8_t * pixma_rgb_to_gray (uint8_t * gptr, uint8_t * sptr, unsigned w, unsigned c);
uint8_t * pixma_binarize_line(pixma_scan_param_t *, uint8_t * dst, uint8_t * src, unsigned width, unsigned c);
/**@}*/
/** \name Command related functions */
/**@{*/
int pixma_cmd_transaction (pixma_t *, const void *cmd, unsigned cmdlen,
void *data, unsigned expected_len);
int pixma_check_result (pixma_cmdbuf_t *);
uint8_t *pixma_newcmd (pixma_cmdbuf_t *, unsigned cmd,
unsigned dataout, unsigned datain);
int pixma_exec (pixma_t *, pixma_cmdbuf_t *);
int pixma_exec_short_cmd (pixma_t *, pixma_cmdbuf_t *, unsigned cmd);
int pixma_map_status_errno (unsigned status);
/**@}*/
#define pixma_fill_checksum(start, end) do { \
*(end) = -pixma_sum_bytes(start, (end)-(start)); \
} while(0)
/** @} end of group subdriver */
/** \addtogroup debug
* @{ */
void pixma_set_debug_level (int level);
#ifndef NDEBUG
void pixma_hexdump (int level, const void *d_, unsigned len);
/* len: length of data or error code.
size: if >= 0, force to print 'size' bytes.
max: maximum number of bytes to print(-1 means no limit). */
void pixma_dump (int level, const char *type, const void *data, int len,
int size, int max);
# define DEBUG_DECLARE_ONLY
# include "../include/sane/sanei_debug.h"
#endif /* NDEBUG */
/** @} end of group debug */
#endif
|
