kernel32: Added support for ctrl-home (aka clear from beginning of line) in line...
[wine] / dlls / sane.ds / ds_image.c
1 /*
2  * Copyright 2000 Corel Corporation
3  * Copyright 2006 CodeWeavers, Aric Stewart
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 #include "config.h"
21
22 #include <stdarg.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wingdi.h"
27 #include "winuser.h"
28 #include "twain.h"
29 #include "sane_i.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(twain);
33
34 /* DG_IMAGE/DAT_IMAGEINFO/MSG_GET */
35 TW_UINT16 SANE_ImageInfoGet (pTW_IDENTITY pOrigin, 
36                               TW_MEMREF pData)
37 {
38 #ifndef SONAME_LIBSANE
39     return TWRC_FAILURE;
40 #else
41     TW_UINT16 twRC = TWRC_SUCCESS;
42     pTW_IMAGEINFO pImageInfo = (pTW_IMAGEINFO) pData;
43     SANE_Status status;
44     SANE_Int resolution;
45
46     TRACE("DG_IMAGE/DAT_IMAGEINFO/MSG_GET\n");
47
48     if (activeDS.currentState != 6 && activeDS.currentState != 7)
49     {
50         twRC = TWRC_FAILURE;
51         activeDS.twCC = TWCC_SEQERROR;
52     }
53     else
54     {
55         if (activeDS.currentState == 6)
56         {
57             /* return general image description information about the image about to be transferred */
58             status = psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
59             TRACE("Getting parameters\n");
60             if (status != SANE_STATUS_GOOD)
61             {
62                 WARN("psane_get_parameters: %s\n", psane_strstatus (status));
63                 psane_cancel (activeDS.deviceHandle);
64                 activeDS.sane_started = FALSE;
65                 activeDS.twCC = TWCC_OPERATIONERROR;
66                 return TWRC_FAILURE;
67             }
68             activeDS.sane_param_valid = TRUE;
69         }
70
71         if (sane_option_get_int(activeDS.deviceHandle, "resolution", &resolution) == SANE_STATUS_GOOD)
72             pImageInfo->XResolution.Whole = pImageInfo->YResolution.Whole = resolution;
73         else
74             pImageInfo->XResolution.Whole = pImageInfo->YResolution.Whole = -1;
75         pImageInfo->XResolution.Frac = 0;
76         pImageInfo->YResolution.Frac = 0;
77         pImageInfo->ImageWidth = activeDS.sane_param.pixels_per_line;
78         pImageInfo->ImageLength = activeDS.sane_param.lines;
79
80         TRACE("Bits per Sample %i\n",activeDS.sane_param.depth);
81         TRACE("Frame Format %i\n",activeDS.sane_param.format);
82
83         if (activeDS.sane_param.format == SANE_FRAME_RGB )
84         {
85             pImageInfo->BitsPerPixel = activeDS.sane_param.depth * 3;
86             pImageInfo->Compression = TWCP_NONE;
87             pImageInfo->Planar = TRUE;
88             pImageInfo->SamplesPerPixel = 3;
89             pImageInfo->BitsPerSample[0] = activeDS.sane_param.depth;
90             pImageInfo->BitsPerSample[1] = activeDS.sane_param.depth;
91             pImageInfo->BitsPerSample[2] = activeDS.sane_param.depth;
92             pImageInfo->PixelType = TWPT_RGB;
93         }
94         else if (activeDS.sane_param.format == SANE_FRAME_GRAY)
95         {
96             pImageInfo->BitsPerPixel = activeDS.sane_param.depth;
97             pImageInfo->Compression = TWCP_NONE;
98             pImageInfo->Planar = TRUE;
99             pImageInfo->SamplesPerPixel = 1;
100             pImageInfo->BitsPerSample[0] = activeDS.sane_param.depth;
101             if (activeDS.sane_param.depth == 1)
102                 pImageInfo->PixelType = TWPT_BW;
103             else
104                 pImageInfo->PixelType = TWPT_GRAY;
105         }
106         else
107         {
108             ERR("Unhandled source frame type %i\n",activeDS.sane_param.format);
109             twRC = TWRC_FAILURE;
110             activeDS.twCC = TWCC_SEQERROR;
111         }
112     }
113
114     return twRC;
115 #endif
116 }
117
118 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_GET */
119 TW_UINT16 SANE_ImageLayoutGet (pTW_IDENTITY pOrigin,
120                                 TW_MEMREF pData)
121 {
122 #ifndef SONAME_LIBSANE
123     return TWRC_FAILURE;
124 #else
125     TW_IMAGELAYOUT *img = (TW_IMAGELAYOUT *) pData;
126     SANE_Fixed tlx_current;
127     SANE_Fixed tly_current;
128     SANE_Fixed brx_current;
129     SANE_Fixed bry_current;
130     SANE_Status status;
131
132     TRACE("DG_IMAGE/DAT_IMAGELAYOUT/MSG_GET\n");
133
134     status = sane_option_probe_scan_area(activeDS.deviceHandle, "tl-x", &tlx_current, NULL, NULL, NULL, NULL);
135     if (status == SANE_STATUS_GOOD)
136         status = sane_option_probe_scan_area(activeDS.deviceHandle, "tl-y", &tly_current, NULL, NULL, NULL, NULL);
137
138     if (status == SANE_STATUS_GOOD)
139         status = sane_option_probe_scan_area(activeDS.deviceHandle, "br-x", &brx_current, NULL, NULL, NULL, NULL);
140
141     if (status == SANE_STATUS_GOOD)
142         status = sane_option_probe_scan_area(activeDS.deviceHandle, "br-y", &bry_current, NULL, NULL, NULL, NULL);
143
144     if (status != SANE_STATUS_GOOD)
145     {
146         activeDS.twCC = sane_status_to_twcc(status);
147         return TWRC_FAILURE;
148     }
149
150     convert_sane_res_to_twain(SANE_UNFIX(tlx_current), SANE_UNIT_MM, &img->Frame.Left, TWUN_INCHES);
151     convert_sane_res_to_twain(SANE_UNFIX(tly_current), SANE_UNIT_MM, &img->Frame.Top, TWUN_INCHES);
152     convert_sane_res_to_twain(SANE_UNFIX(brx_current), SANE_UNIT_MM, &img->Frame.Right, TWUN_INCHES);
153     convert_sane_res_to_twain(SANE_UNFIX(bry_current), SANE_UNIT_MM, &img->Frame.Bottom, TWUN_INCHES);
154
155     img->DocumentNumber = 1;
156     img->PageNumber = 1;
157     img->FrameNumber = 1;
158
159     activeDS.twCC = TWCC_SUCCESS;
160     return TWRC_SUCCESS;
161 #endif
162 }
163
164 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_GETDEFAULT */
165 TW_UINT16 SANE_ImageLayoutGetDefault (pTW_IDENTITY pOrigin, 
166                                        TW_MEMREF pData)
167 {
168     FIXME ("stub!\n");
169
170     return TWRC_FAILURE;
171 }
172
173 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_RESET */
174 TW_UINT16 SANE_ImageLayoutReset (pTW_IDENTITY pOrigin, 
175                                   TW_MEMREF pData)
176 {
177     FIXME ("stub!\n");
178
179     return TWRC_FAILURE;
180 }
181
182 #ifdef SONAME_LIBSANE
183 static TW_UINT16 set_one_imagecoord(const char *option_name, TW_FIX32 val, BOOL *changed)
184 {
185     double d = val.Whole + ((double) val.Frac / 65536.0);
186     int set_status = 0;
187     SANE_Status status;
188     status = sane_option_set_fixed(activeDS.deviceHandle, option_name,
189              SANE_FIX((d * 254) / 10), &set_status);
190     if (status != SANE_STATUS_GOOD)
191     {
192         activeDS.twCC = sane_status_to_twcc(status);
193         return TWRC_FAILURE;
194     }
195     if (set_status & SANE_INFO_INEXACT)
196         *changed = TRUE;
197     return TWRC_SUCCESS;
198 }
199 #endif
200
201 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_SET */
202 TW_UINT16 SANE_ImageLayoutSet (pTW_IDENTITY pOrigin,
203                                 TW_MEMREF pData)
204 {
205 #ifndef SONAME_LIBSANE
206     return TWRC_FAILURE;
207 #else
208     TW_IMAGELAYOUT *img = (TW_IMAGELAYOUT *) pData;
209     BOOL changed = FALSE;
210     TW_UINT16 twrc;
211
212     TRACE("DG_IMAGE/DAT_IMAGELAYOUT/MSG_SET\n");
213     TRACE("Frame: [Left %x.%x|Top %x.%x|Right %x.%x|Bottom %x.%x]\n",
214             img->Frame.Left.Whole, img->Frame.Left.Frac,
215             img->Frame.Top.Whole, img->Frame.Top.Frac,
216             img->Frame.Right.Whole, img->Frame.Right.Frac,
217             img->Frame.Bottom.Whole, img->Frame.Bottom.Frac);
218
219     twrc = set_one_imagecoord("tl-x", img->Frame.Left, &changed);
220     if (twrc != TWRC_SUCCESS)
221         return (twrc);
222
223     twrc = set_one_imagecoord("tl-y", img->Frame.Top, &changed);
224     if (twrc != TWRC_SUCCESS)
225         return (twrc);
226
227     twrc = set_one_imagecoord("br-x", img->Frame.Right, &changed);
228     if (twrc != TWRC_SUCCESS)
229         return (twrc);
230
231     twrc = set_one_imagecoord("br-y", img->Frame.Bottom, &changed);
232     if (twrc != TWRC_SUCCESS)
233         return (twrc);
234
235     activeDS.twCC = TWCC_SUCCESS;
236     return changed ? TWRC_CHECKSTATUS : TWRC_SUCCESS;
237 #endif
238 }
239
240 /* DG_IMAGE/DAT_IMAGEMEMXFER/MSG_GET */
241 TW_UINT16 SANE_ImageMemXferGet (pTW_IDENTITY pOrigin, 
242                                  TW_MEMREF pData)
243 {
244 #ifndef SONAME_LIBSANE
245     return TWRC_FAILURE;
246 #else
247     TW_UINT16 twRC = TWRC_SUCCESS;
248     pTW_IMAGEMEMXFER pImageMemXfer = (pTW_IMAGEMEMXFER) pData;
249     SANE_Status status = SANE_STATUS_GOOD;
250
251     TRACE ("DG_IMAGE/DAT_IMAGEMEMXFER/MSG_GET\n");
252
253     if (activeDS.currentState < 6 || activeDS.currentState > 7)
254     {
255         twRC = TWRC_FAILURE;
256         activeDS.twCC = TWCC_SEQERROR;
257     }
258     else
259     {
260         LPBYTE buffer;
261         int buff_len = 0;
262         int consumed_len = 0;
263         LPBYTE ptr;
264         int rows;
265
266         /* Transfer an image from the source to the application */
267         if (activeDS.currentState == 6)
268         {
269
270             /* trigger scanning dialog */
271             activeDS.progressWnd = ScanningDialogBox(NULL,0);
272
273             ScanningDialogBox(activeDS.progressWnd,0);
274
275             if (! activeDS.sane_started)
276             {
277                 status = psane_start (activeDS.deviceHandle);
278                 if (status != SANE_STATUS_GOOD)
279                 {
280                     WARN("psane_start: %s\n", psane_strstatus (status));
281                     psane_cancel (activeDS.deviceHandle);
282                     activeDS.twCC = TWCC_OPERATIONERROR;
283                     return TWRC_FAILURE;
284                 }
285                 activeDS.sane_started = TRUE;
286             }
287
288             status = psane_get_parameters (activeDS.deviceHandle,
289                     &activeDS.sane_param);
290             activeDS.sane_param_valid = TRUE;
291
292             if (status != SANE_STATUS_GOOD)
293             {
294                 WARN("psane_get_parameters: %s\n", psane_strstatus (status));
295                 psane_cancel (activeDS.deviceHandle);
296                 activeDS.sane_started = FALSE;
297                 activeDS.twCC = TWCC_OPERATIONERROR;
298                 return TWRC_FAILURE;
299             }
300
301             TRACE("Acquiring image %dx%dx%d bits (format=%d last=%d) from sane...\n"
302               , activeDS.sane_param.pixels_per_line, activeDS.sane_param.lines,
303               activeDS.sane_param.depth, activeDS.sane_param.format,
304               activeDS.sane_param.last_frame);
305
306             activeDS.currentState = 7;
307         }
308
309         /* access memory buffer */
310         if (pImageMemXfer->Memory.Length < activeDS.sane_param.bytes_per_line)
311         {
312             psane_cancel (activeDS.deviceHandle);
313             activeDS.sane_started = FALSE;
314             activeDS.twCC = TWCC_BADVALUE;
315             return TWRC_FAILURE;
316         }
317
318         if (pImageMemXfer->Memory.Flags & TWMF_HANDLE)
319         {
320             FIXME("Memory Handle, may not be locked correctly\n");
321             buffer = LocalLock(pImageMemXfer->Memory.TheMem);
322         }
323         else
324             buffer = pImageMemXfer->Memory.TheMem;
325        
326         memset(buffer,0,pImageMemXfer->Memory.Length);
327
328         ptr = buffer;
329         consumed_len = 0;
330         rows = pImageMemXfer->Memory.Length / activeDS.sane_param.bytes_per_line;
331
332         /* must fill full lines */
333         while (consumed_len < (activeDS.sane_param.bytes_per_line*rows) && 
334                 status == SANE_STATUS_GOOD)
335         {
336             status = psane_read (activeDS.deviceHandle, ptr,
337                     (activeDS.sane_param.bytes_per_line*rows) - consumed_len ,
338                     &buff_len);
339             consumed_len += buff_len;
340             ptr += buff_len;
341         }
342
343         if (status == SANE_STATUS_GOOD || status == SANE_STATUS_EOF)
344         {
345             pImageMemXfer->Compression = TWCP_NONE;
346             pImageMemXfer->BytesPerRow = activeDS.sane_param.bytes_per_line;
347             pImageMemXfer->Columns = activeDS.sane_param.pixels_per_line;
348             pImageMemXfer->Rows = rows;
349             pImageMemXfer->XOffset = 0;
350             pImageMemXfer->YOffset = 0;
351             pImageMemXfer->BytesWritten = consumed_len;
352
353             ScanningDialogBox(activeDS.progressWnd, consumed_len);
354
355             if (status == SANE_STATUS_EOF)
356             {
357                 ScanningDialogBox(activeDS.progressWnd, -1);
358                 TRACE("psane_read: %s\n", psane_strstatus (status));
359                 psane_cancel (activeDS.deviceHandle);
360                 activeDS.sane_started = FALSE;
361                 twRC = TWRC_XFERDONE;
362             }
363             activeDS.twCC = TWRC_SUCCESS;
364         }
365         else if (status != SANE_STATUS_EOF)
366         {
367             ScanningDialogBox(activeDS.progressWnd, -1);
368             WARN("psane_read: %s\n", psane_strstatus (status));
369             psane_cancel (activeDS.deviceHandle);
370             activeDS.sane_started = FALSE;
371             activeDS.twCC = TWCC_OPERATIONERROR;
372             twRC = TWRC_FAILURE;
373         }
374     }
375
376     if (pImageMemXfer->Memory.Flags & TWMF_HANDLE)
377         LocalUnlock(pImageMemXfer->Memory.TheMem);
378     
379     return twRC;
380 #endif
381 }
382
383 #ifdef SONAME_LIBSANE
384 static SANE_Status read_one_line(SANE_Handle h, BYTE *line, int len)
385 {
386     int read_len;
387     SANE_Status status;
388
389     for (;;)
390     {
391         read_len = 0;
392         status = psane_read (activeDS.deviceHandle, line, len, &read_len);
393         if (status != SANE_STATUS_GOOD)
394             break;
395
396         if (read_len == len)
397             break;
398
399         line += read_len;
400         len -= read_len;
401     }
402
403     return status;
404 }
405 #endif
406
407 /* DG_IMAGE/DAT_IMAGENATIVEXFER/MSG_GET */
408 TW_UINT16 SANE_ImageNativeXferGet (pTW_IDENTITY pOrigin, 
409                                     TW_MEMREF pData)
410 {
411 #ifndef SONAME_LIBSANE
412     return TWRC_FAILURE;
413 #else
414     TW_UINT16 twRC = TWRC_SUCCESS;
415     pTW_UINT32 pHandle = (pTW_UINT32) pData;
416     SANE_Status status;
417     HANDLE hDIB;
418     BITMAPINFOHEADER *header = NULL;
419     int dib_bytes;
420     int dib_bytes_per_line;
421     BYTE *line;
422     RGBQUAD *colors;
423     int color_size = 0;
424     int i;
425     BYTE *p;
426
427     TRACE("DG_IMAGE/DAT_IMAGENATIVEXFER/MSG_GET\n");
428
429     if (activeDS.currentState != 6)
430     {
431         twRC = TWRC_FAILURE;
432         activeDS.twCC = TWCC_SEQERROR;
433     }
434     else
435     {
436         /* Transfer an image from the source to the application */
437         if (! activeDS.sane_started)
438         {
439             status = psane_start (activeDS.deviceHandle);
440             if (status != SANE_STATUS_GOOD)
441             {
442                 WARN("psane_start: %s\n", psane_strstatus (status));
443                 psane_cancel (activeDS.deviceHandle);
444                 activeDS.twCC = TWCC_OPERATIONERROR;
445                 return TWRC_FAILURE;
446             }
447             activeDS.sane_started = TRUE;
448         }
449
450         status = psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
451         activeDS.sane_param_valid = TRUE;
452         if (status != SANE_STATUS_GOOD)
453         {
454             WARN("psane_get_parameters: %s\n", psane_strstatus (status));
455             psane_cancel (activeDS.deviceHandle);
456             activeDS.sane_started = FALSE;
457             activeDS.twCC = TWCC_OPERATIONERROR;
458             return TWRC_FAILURE;
459         }
460
461         if (activeDS.sane_param.format == SANE_FRAME_GRAY)
462         {
463             if (activeDS.sane_param.depth == 8)
464                 color_size = (1 << 8) * sizeof(*colors);
465             else if (activeDS.sane_param.depth == 1)
466                 ;
467             else
468             {
469                 FIXME("For NATIVE, we support only 1 bit monochrome and 8 bit Grayscale, not %d\n", activeDS.sane_param.depth);
470                 psane_cancel (activeDS.deviceHandle);
471                 activeDS.sane_started = FALSE;
472                 activeDS.twCC = TWCC_OPERATIONERROR;
473                 return TWRC_FAILURE;
474             }
475         }
476         else if (activeDS.sane_param.format != SANE_FRAME_RGB)
477         {
478             FIXME("For NATIVE, we support only GRAY and RGB, not %d\n", activeDS.sane_param.format);
479             psane_cancel (activeDS.deviceHandle);
480             activeDS.sane_started = FALSE;
481             activeDS.twCC = TWCC_OPERATIONERROR;
482             return TWRC_FAILURE;
483         }
484
485         TRACE("Acquiring image %dx%dx%d bits (format=%d last=%d bpl=%d) from sane...\n"
486               , activeDS.sane_param.pixels_per_line, activeDS.sane_param.lines,
487               activeDS.sane_param.depth, activeDS.sane_param.format,
488               activeDS.sane_param.last_frame, activeDS.sane_param.bytes_per_line);
489
490         dib_bytes_per_line = ((activeDS.sane_param.bytes_per_line + 3) / 4) * 4;
491         dib_bytes = activeDS.sane_param.lines * dib_bytes_per_line;
492
493         hDIB = GlobalAlloc(GMEM_ZEROINIT, dib_bytes + sizeof(*header) + color_size);
494         if (hDIB)
495            header = GlobalLock(hDIB);
496
497         if (!header)
498         {
499             psane_cancel (activeDS.deviceHandle);
500             activeDS.sane_started = FALSE;
501             activeDS.twCC = TWCC_LOWMEMORY;
502             if (hDIB)
503                 GlobalFree(hDIB);
504             return TWRC_FAILURE;
505         }
506
507         header->biSize = sizeof (*header);
508         header->biWidth = activeDS.sane_param.pixels_per_line;
509         header->biHeight = activeDS.sane_param.lines;
510         header->biPlanes = 1;
511         header->biCompression = BI_RGB;
512         if (activeDS.sane_param.format == SANE_FRAME_RGB)
513             header->biBitCount = activeDS.sane_param.depth * 3;
514         if (activeDS.sane_param.format == SANE_FRAME_GRAY)
515             header->biBitCount = activeDS.sane_param.depth;
516         header->biSizeImage = dib_bytes;
517         header->biXPelsPerMeter = 0;
518         header->biYPelsPerMeter = 0;
519         header->biClrUsed = 0;
520         header->biClrImportant = 0;
521
522         p = (BYTE *)(header + 1);
523
524         if (color_size > 0)
525         {
526             colors = (RGBQUAD *) p;
527             p += color_size;
528             for (i = 0; i < (color_size / sizeof(*colors)); i++)
529                 colors[i].rgbBlue = colors[i].rgbRed = colors[i].rgbGreen = i;
530         }
531
532
533         /* Sane returns data in top down order.  Acrobat does best with
534            a bottom up DIB being returned.  */
535         line = p + (activeDS.sane_param.lines - 1) * dib_bytes_per_line;
536         for (i = activeDS.sane_param.lines - 1; i >= 0; i--)
537         {
538             activeDS.progressWnd = ScanningDialogBox(activeDS.progressWnd,
539                     ((activeDS.sane_param.lines - 1 - i) * 100)
540                             /
541                     (activeDS.sane_param.lines - 1));
542
543             status = read_one_line(activeDS.deviceHandle, line,
544                             activeDS.sane_param.bytes_per_line);
545             if (status != SANE_STATUS_GOOD)
546                 break;
547
548             line -= dib_bytes_per_line;
549         }
550         activeDS.progressWnd = ScanningDialogBox(activeDS.progressWnd, -1);
551
552         GlobalUnlock(hDIB);
553
554         if (status != SANE_STATUS_GOOD && status != SANE_STATUS_EOF)
555         {
556             WARN("psane_read: %s, reading line %d\n", psane_strstatus(status), i);
557             psane_cancel (activeDS.deviceHandle);
558             activeDS.sane_started = FALSE;
559             activeDS.twCC = TWCC_OPERATIONERROR;
560             GlobalFree(hDIB);
561             return TWRC_FAILURE;
562         }
563
564         psane_cancel (activeDS.deviceHandle);
565         activeDS.sane_started = FALSE;
566         *pHandle = (UINT_PTR)hDIB;
567         twRC = TWRC_XFERDONE;
568         activeDS.twCC = TWCC_SUCCESS;
569         activeDS.currentState = 7;
570     }
571     return twRC;
572 #endif
573 }