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     FIXME ("stub!\n");
 123
 124     return TWRC_FAILURE;
 125 }
 126
 127 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_GETDEFAULT */
 128 TW_UINT16 SANE_ImageLayoutGetDefault (pTW_IDENTITY pOrigin,
 129                                        TW_MEMREF pData)
 130 {
 131     FIXME ("stub!\n");
 132
 133     return TWRC_FAILURE;
 134 }
 135
 136 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_RESET */
 137 TW_UINT16 SANE_ImageLayoutReset (pTW_IDENTITY pOrigin,
 138                                   TW_MEMREF pData)
 139 {
 140     FIXME ("stub!\n");
 141
 142     return TWRC_FAILURE;
 143 }
 144
 145 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_SET */
 146 TW_UINT16 SANE_ImageLayoutSet (pTW_IDENTITY pOrigin,
 147                                 TW_MEMREF pData)
 148 {
 149     FIXME ("stub!\n");
 150
 151     return TWRC_FAILURE;
 152 }
 153
 154 /* DG_IMAGE/DAT_IMAGEMEMXFER/MSG_GET */
 155 TW_UINT16 SANE_ImageMemXferGet (pTW_IDENTITY pOrigin,
 156                                  TW_MEMREF pData)
 157 {
 158 #ifndef SONAME_LIBSANE
 159     return TWRC_FAILURE;
 160 #else
 161     TW_UINT16 twRC = TWRC_SUCCESS;
 162     pTW_IMAGEMEMXFER pImageMemXfer = (pTW_IMAGEMEMXFER) pData;
 163     SANE_Status status = SANE_STATUS_GOOD;
 164
 165     TRACE ("DG_IMAGE/DAT_IMAGEMEMXFER/MSG_GET\n");
 166
 167     if (activeDS.currentState < 6 || activeDS.currentState > 7)
 168     {
 169         twRC = TWRC_FAILURE;
 170         activeDS.twCC = TWCC_SEQERROR;
 171     }
 172     else
 173     {
 174         LPBYTE buffer;
 175         int buff_len = 0;
 176         int consumed_len = 0;
 177         LPBYTE ptr;
 178         int rows;
 179
 180         /* Transfer an image from the source to the application */
 181         if (activeDS.currentState == 6)
 182         {
 183
 184             /* trigger scanning dialog */
 185             activeDS.progressWnd = ScanningDialogBox(NULL,0);
 186
 187             ScanningDialogBox(activeDS.progressWnd,0);
 188
 189             if (! activeDS.sane_started)
 190             {
 191                 status = psane_start (activeDS.deviceHandle);
 192                 if (status != SANE_STATUS_GOOD)
 193                 {
 194                     WARN("psane_start: %s\n", psane_strstatus (status));
 195                     psane_cancel (activeDS.deviceHandle);
 196                     activeDS.twCC = TWCC_OPERATIONERROR;
 197                     return TWRC_FAILURE;
 198                 }
 199                 activeDS.sane_started = TRUE;
 200             }
 201
 202             status = psane_get_parameters (activeDS.deviceHandle,
 203                     &activeDS.sane_param);
 204             activeDS.sane_param_valid = TRUE;
 205
 206             if (status != SANE_STATUS_GOOD)
 207             {
 208                 WARN("psane_get_parameters: %s\n", psane_strstatus (status));
 209                 psane_cancel (activeDS.deviceHandle);
 210                 activeDS.sane_started = FALSE;
 211                 activeDS.twCC = TWCC_OPERATIONERROR;
 212                 return TWRC_FAILURE;
 213             }
 214
 215             TRACE("Acquiring image %dx%dx%d bits (format=%d last=%d) from sane...\n"
 216               , activeDS.sane_param.pixels_per_line, activeDS.sane_param.lines,
 217               activeDS.sane_param.depth, activeDS.sane_param.format,
 218               activeDS.sane_param.last_frame);
 219
 220             activeDS.currentState = 7;
 221         }
 222
 223         /* access memory buffer */
 224         if (pImageMemXfer->Memory.Length < activeDS.sane_param.bytes_per_line)
 225         {
 226             psane_cancel (activeDS.deviceHandle);
 227             activeDS.sane_started = FALSE;
 228             activeDS.twCC = TWCC_BADVALUE;
 229             return TWRC_FAILURE;
 230         }
 231
 232         if (pImageMemXfer->Memory.Flags & TWMF_HANDLE)
 233         {
 234             FIXME("Memory Handle, may not be locked correctly\n");
 235             buffer = LocalLock(pImageMemXfer->Memory.TheMem);
 236         }
 237         else
 238             buffer = pImageMemXfer->Memory.TheMem;
 239
 240         memset(buffer,0,pImageMemXfer->Memory.Length);
 241
 242         ptr = buffer;
 243         consumed_len = 0;
 244         rows = pImageMemXfer->Memory.Length / activeDS.sane_param.bytes_per_line;
 245
 246         /* must fill full lines */
 247         while (consumed_len < (activeDS.sane_param.bytes_per_line*rows) &&
 248                 status == SANE_STATUS_GOOD)
 249         {
 250             status = psane_read (activeDS.deviceHandle, ptr,
 251                     (activeDS.sane_param.bytes_per_line*rows) - consumed_len ,
 252                     &buff_len);
 253             consumed_len += buff_len;
 254             ptr += buff_len;
 255         }
 256
 257         if (status == SANE_STATUS_GOOD || status == SANE_STATUS_EOF)
 258         {
 259             pImageMemXfer->Compression = TWCP_NONE;
 260             pImageMemXfer->BytesPerRow = activeDS.sane_param.bytes_per_line;
 261             pImageMemXfer->Columns = activeDS.sane_param.pixels_per_line;
 262             pImageMemXfer->Rows = rows;
 263             pImageMemXfer->XOffset = 0;
 264             pImageMemXfer->YOffset = 0;
 265             pImageMemXfer->BytesWritten = consumed_len;
 266
 267             ScanningDialogBox(activeDS.progressWnd, consumed_len);
 268
 269             if (status == SANE_STATUS_EOF)
 270             {
 271                 ScanningDialogBox(activeDS.progressWnd, -1);
 272                 TRACE("psane_read: %s\n", psane_strstatus (status));
 273                 psane_cancel (activeDS.deviceHandle);
 274                 activeDS.sane_started = FALSE;
 275                 twRC = TWRC_XFERDONE;
 276             }
 277             activeDS.twCC = TWRC_SUCCESS;
 278         }
 279         else if (status != SANE_STATUS_EOF)
 280         {
 281             ScanningDialogBox(activeDS.progressWnd, -1);
 282             WARN("psane_read: %s\n", psane_strstatus (status));
 283             psane_cancel (activeDS.deviceHandle);
 284             activeDS.sane_started = FALSE;
 285             activeDS.twCC = TWCC_OPERATIONERROR;
 286             twRC = TWRC_FAILURE;
 287         }
 288     }
 289
 290     if (pImageMemXfer->Memory.Flags & TWMF_HANDLE)
 291         LocalUnlock(pImageMemXfer->Memory.TheMem);
 292
 293     return twRC;
 294 #endif
 295 }
 296
 297 #ifdef SONAME_LIBSANE
 298 static SANE_Status read_one_line(SANE_Handle h, BYTE *line, int len)
 299 {
 300     int read_len;
 301     SANE_Status status;
 302
 303     for (;;)
 304     {
 305         read_len = 0;
 306         status = psane_read (activeDS.deviceHandle, line, len, &read_len);
 307         if (status != SANE_STATUS_GOOD)
 308             break;
 309
 310         if (read_len == len)
 311             break;
 312
 313         line += read_len;
 314         len -= read_len;
 315     }
 316
 317     return status;
 318 }
 319 #endif
 320
 321 /* DG_IMAGE/DAT_IMAGENATIVEXFER/MSG_GET */
 322 TW_UINT16 SANE_ImageNativeXferGet (pTW_IDENTITY pOrigin,
 323                                     TW_MEMREF pData)
 324 {
 325 #ifndef SONAME_LIBSANE
 326     return TWRC_FAILURE;
 327 #else
 328     TW_UINT16 twRC = TWRC_SUCCESS;
 329     pTW_UINT32 pHandle = (pTW_UINT32) pData;
 330     SANE_Status status;
 331     HANDLE hDIB;
 332     BITMAPINFOHEADER *header = NULL;
 333     int dib_bytes;
 334     int dib_bytes_per_line;
 335     BYTE *line;
 336     RGBQUAD *colors;
 337     int color_size = 0;
 338     int i;
 339     BYTE *p;
 340
 341     TRACE("DG_IMAGE/DAT_IMAGENATIVEXFER/MSG_GET\n");
 342
 343     if (activeDS.currentState != 6)
 344     {
 345         twRC = TWRC_FAILURE;
 346         activeDS.twCC = TWCC_SEQERROR;
 347     }
 348     else
 349     {
 350         /* Transfer an image from the source to the application */
 351         if (! activeDS.sane_started)
 352         {
 353             status = psane_start (activeDS.deviceHandle);
 354             if (status != SANE_STATUS_GOOD)
 355             {
 356                 WARN("psane_start: %s\n", psane_strstatus (status));
 357                 psane_cancel (activeDS.deviceHandle);
 358                 activeDS.twCC = TWCC_OPERATIONERROR;
 359                 return TWRC_FAILURE;
 360             }
 361             activeDS.sane_started = TRUE;
 362         }
 363
 364         status = psane_get_parameters (activeDS.deviceHandle, &activeDS.sane_param);
 365         activeDS.sane_param_valid = TRUE;
 366         if (status != SANE_STATUS_GOOD)
 367         {
 368             WARN("psane_get_parameters: %s\n", psane_strstatus (status));
 369             psane_cancel (activeDS.deviceHandle);
 370             activeDS.sane_started = FALSE;
 371             activeDS.twCC = TWCC_OPERATIONERROR;
 372             return TWRC_FAILURE;
 373         }
 374
 375         if (activeDS.sane_param.format == SANE_FRAME_GRAY)
 376         {
 377             if (activeDS.sane_param.depth == 8)
 378                 color_size = (1 << 8) * sizeof(*colors);
 379             else if (activeDS.sane_param.depth == 1)
 380                 ;
 381             else
 382             {
 383                 FIXME("For NATIVE, we support only 1 bit monochrome and 8 bit Grayscale, not %d\n", activeDS.sane_param.depth);
 384                 psane_cancel (activeDS.deviceHandle);
 385                 activeDS.sane_started = FALSE;
 386                 activeDS.twCC = TWCC_OPERATIONERROR;
 387                 return TWRC_FAILURE;
 388             }
 389         }
 390         else if (activeDS.sane_param.format != SANE_FRAME_RGB)
 391         {
 392             FIXME("For NATIVE, we support only GRAY and RGB, not %d\n", activeDS.sane_param.format);
 393             psane_cancel (activeDS.deviceHandle);
 394             activeDS.sane_started = FALSE;
 395             activeDS.twCC = TWCC_OPERATIONERROR;
 396             return TWRC_FAILURE;
 397         }
 398
 399         TRACE("Acquiring image %dx%dx%d bits (format=%d last=%d bpl=%d) from sane...\n"
 400               , activeDS.sane_param.pixels_per_line, activeDS.sane_param.lines,
 401               activeDS.sane_param.depth, activeDS.sane_param.format,
 402               activeDS.sane_param.last_frame, activeDS.sane_param.bytes_per_line);
 403
 404         dib_bytes_per_line = ((activeDS.sane_param.bytes_per_line + 3) / 4) * 4;
 405         dib_bytes = activeDS.sane_param.lines * dib_bytes_per_line;
 406
 407         hDIB = GlobalAlloc(GMEM_ZEROINIT, dib_bytes + sizeof(*header) + color_size);
 408         if (hDIB)
 409            header = GlobalLock(hDIB);
 410
 411         if (!header)
 412         {
 413             psane_cancel (activeDS.deviceHandle);
 414             activeDS.sane_started = FALSE;
 415             activeDS.twCC = TWCC_LOWMEMORY;
 416             if (hDIB)
 417                 GlobalFree(hDIB);
 418             return TWRC_FAILURE;
 419         }
 420
 421         header->biSize = sizeof (*header);
 422         header->biWidth = activeDS.sane_param.pixels_per_line;
 423         header->biHeight = activeDS.sane_param.lines;
 424         header->biPlanes = 1;
 425         header->biCompression = BI_RGB;
 426         if (activeDS.sane_param.format == SANE_FRAME_RGB)
 427             header->biBitCount = activeDS.sane_param.depth * 3;
 428         if (activeDS.sane_param.format == SANE_FRAME_GRAY)
 429             header->biBitCount = activeDS.sane_param.depth;
 430         header->biSizeImage = dib_bytes;
 431         header->biXPelsPerMeter = 0;
 432         header->biYPelsPerMeter = 0;
 433         header->biClrUsed = 0;
 434         header->biClrImportant = 0;
 435
 436         p = (BYTE *)(header + 1);
 437
 438         if (color_size > 0)
 439         {
 440             colors = (RGBQUAD *) p;
 441             p += color_size;
 442             for (i = 0; i < (color_size / sizeof(*colors)); i++)
 443                 colors[i].rgbBlue = colors[i].rgbRed = colors[i].rgbGreen = i;
 444         }
 445
 446
 447         /* Sane returns data in top down order.  Acrobat does best with
 448            a bottom up DIB being returned.  */
 449         line = p + (activeDS.sane_param.lines - 1) * dib_bytes_per_line;
 450         for (i = activeDS.sane_param.lines - 1; i >= 0; i--)
 451         {
 452             activeDS.progressWnd = ScanningDialogBox(activeDS.progressWnd,
 453                     ((activeDS.sane_param.lines - 1 - i) * 100)
 454                             /
 455                     (activeDS.sane_param.lines - 1));
 456
 457             status = read_one_line(activeDS.deviceHandle, line,
 458                             activeDS.sane_param.bytes_per_line);
 459             if (status != SANE_STATUS_GOOD)
 460                 break;
 461
 462             line -= dib_bytes_per_line;
 463         }
 464         activeDS.progressWnd = ScanningDialogBox(activeDS.progressWnd, -1);
 465
 466         GlobalUnlock(hDIB);
 467
 468         if (status != SANE_STATUS_GOOD && status != SANE_STATUS_EOF)
 469         {
 470             WARN("psane_read: %s, reading line %d\n", psane_strstatus(status), i);
 471             psane_cancel (activeDS.deviceHandle);
 472             activeDS.sane_started = FALSE;
 473             activeDS.twCC = TWCC_OPERATIONERROR;
 474             GlobalFree(hDIB);
 475             return TWRC_FAILURE;
 476         }
 477
 478         psane_cancel (activeDS.deviceHandle);
 479         activeDS.sane_started = FALSE;
 480         *pHandle = (TW_UINT32)hDIB;
 481         twRC = TWRC_XFERDONE;
 482         activeDS.twCC = TWCC_SUCCESS;
 483         activeDS.currentState = 7;
 484     }
 485     return twRC;
 486 #endif
 487 }