home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / twain / tw_dump.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-11  |  7.5 KB  |  267 lines
  1. /*  
  2.  * TWAIN Plug-in
  3.  * Copyright (C) 1999 Craig Setera
  4.  * Craig Setera <setera@home.com>
  5.  * 03/31/1999
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program; if not, write to the Free Software
  19.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20.  *
  21.  *
  22.  * Based on (at least) the following plug-ins:
  23.  * Screenshot
  24.  * GIF
  25.  * Randomize
  26.  *
  27.  * Any suggestions, bug-reports or patches are welcome.
  28.  * 
  29.  * This plug-in interfaces to the TWAIN support library in order
  30.  * to capture images from TWAIN devices directly into GIMP images.
  31.  * The plug-in is capable of acquiring the following type of
  32.  * images:
  33.  * - B/W (1 bit images translated to grayscale B/W)
  34.  * - Grayscale up to 16 bits per pixel
  35.  * - RGB up to 16 bits per sample (24, 30, 36, etc.)
  36.  * - Paletted images (both Gray and RGB)
  37.  *
  38.  * Prerequisites:
  39.  *  This plug-in will not compile on anything other than a Win32
  40.  *  platform.  Although the TWAIN documentation implies that there
  41.  *  is TWAIN support available on Macintosh, I neither have a 
  42.  *  Macintosh nor the interest in porting this.  If anyone else
  43.  *  has an interest, consult www.twain.org for more information on
  44.  *  interfacing to TWAIN.
  45.  *
  46.  * Known problems:
  47.  * - Multiple image transfers will hang the plug-in.  The current
  48.  *   configuration compiles with a maximum of single image transfers.
  49.  */
  50.  
  51. /* 
  52.  * Revision history
  53.  *  (02/07/99)  v0.1   First working version (internal)
  54.  *  (02/09/99)  v0.2   First release to anyone other than myself
  55.  *  (02/15/99)  v0.3   Added image dump and read support for debugging
  56.  *  (03/31/99)  v0.5   Added support for multi-byte samples and paletted 
  57.  *                     images.
  58.  */
  59.  
  60. #include <stdio.h>
  61. #include <string.h>
  62. #include "libgimp/gimp.h"
  63. #include "tw_dump.h"
  64. #include "tw_func.h"
  65. #include "tw_util.h"
  66.  
  67. /* File variables */
  68. static FILE *outputFile = NULL;
  69. extern pTW_SESSION twSession;
  70.  
  71. /*
  72.  * dumpPreTransferCallback
  73.  *
  74.  * This callback function is called before any images
  75.  * are transferred.  Set up the one time only stuff.
  76.  */
  77. void
  78. dumpPreTransferCallback(void *clientData)
  79. {
  80.   /* Open our output file... Not settable... Always
  81.    * write to the root directory.  Simplistic, but
  82.    * gets the job done.
  83.    */
  84.   outputFile = fopen(DUMP_FILE, "wb");
  85. }
  86.  
  87. /*
  88.  * dumpBeginTransferCallback
  89.  *
  90.  * The following function is called at the beginning
  91.  * of each image transfer.
  92.  */
  93. int
  94. dumpBeginTransferCallback(pTW_IMAGEINFO imageInfo, void *clientData)
  95. {
  96.   logBegin(imageInfo, clientData);
  97.  
  98.   /* Dump the image information */
  99.   fwrite((void *) imageInfo, sizeof(TW_IMAGEINFO), 1, outputFile);
  100.  
  101.   /* Keep going */
  102.   return TRUE;
  103. }
  104.     
  105. /*
  106.  * dumpDataTransferCallback
  107.  *
  108.  * The following function is called for each memory
  109.  * block that is transferred from the data source.
  110.  */
  111. int 
  112. dumpDataTransferCallback(pTW_IMAGEINFO imageInfo,
  113.              pTW_IMAGEMEMXFER imageMemXfer,
  114.              void *clientData)
  115. {
  116.   int flag = 1;
  117.  
  118.   logData(imageInfo, imageMemXfer, clientData);
  119.  
  120.   /* Write a flag that says that this is a data packet */
  121.   fwrite((void *) &flag, sizeof(int), 1, outputFile);
  122.  
  123.   /* Dump the memory information */
  124.   fwrite((void *) imageMemXfer, sizeof(TW_IMAGEMEMXFER), 1, outputFile);
  125.   fwrite((void *) imageMemXfer->Memory.TheMem,
  126.      1, imageMemXfer->BytesWritten, outputFile);
  127.  
  128.   /* Keep going */
  129.   return TRUE;
  130. }
  131.     
  132. /*
  133.  * dumpEndTransferCallback
  134.  *
  135.  * The following function is called at the end of the
  136.  * image transfer.  The caller will be handed
  137.  * the image transfer completion state.  The
  138.  * following values (defined in twain.h) are
  139.  * possible:
  140.  *
  141.  * TWRC_XFERDONE
  142.  *  The transfer completed successfully
  143.  * TWRC_CANCEL
  144.  *  The transfer was completed by the user
  145.  * TWRC_FAILURE
  146.  *  The transfer failed.
  147.  */
  148. int
  149. dumpEndTransferCallback(int completionState, int pendingCount, void *clientData)
  150. {
  151.   int flag = 0;
  152.  
  153.   /* Write a flag that says that this is a data packet */
  154.   fwrite((void *) &flag, sizeof(int), 1, outputFile);
  155.  
  156.   /* Write the necessary data */
  157.   fwrite(&completionState, sizeof(int), 1, outputFile);
  158.   fwrite(&pendingCount, sizeof(int), 1, outputFile);
  159.  
  160.   /* Only ever transfer a single image */
  161.   return FALSE;
  162. }
  163.  
  164. /*
  165.  * dumpPostTransferCallback
  166.  *
  167.  * This callback function will be called
  168.  * after all possible images have been
  169.  * transferred.
  170.  */
  171. void
  172. dumpPostTransferCallback(int pendingCount, void *clientData)
  173. {
  174.   char buffer[128];
  175.  
  176.   /* Shut things down. */
  177.   if (pendingCount != 0)
  178.     cancelPendingTransfers(twSession);
  179.  
  180.   /* This will close the datasource and datasource
  181.    * manager.  Then the message queue will be shut
  182.    * down and the run() procedure will finally be
  183.    * able to finish.
  184.    */
  185.   disableDS(twSession);
  186.   closeDS(twSession);
  187.   closeDSM(twSession);
  188.         
  189.   /* Close the dump file */
  190.   fclose(outputFile);
  191.  
  192.   /* Tell the user */
  193.   sprintf(buffer, "Image dumped to file %s\n", DUMP_FILE);
  194.   gimp_message(buffer);
  195.  
  196.   /* Post a message to close up the application */
  197.   PostQuitMessage(0);
  198. }
  199.  
  200. /*
  201.  * readDumpedImage
  202.  *
  203.  * Get a previously dumped image.
  204.  */
  205. void readDumpedImage(pTW_SESSION twSession)
  206. {
  207.   int moreData;
  208.   int completionState;
  209.   int pendingCount;
  210.  
  211.   TW_IMAGEINFO imageInfo;
  212.   TW_IMAGEMEMXFER imageMemXfer;
  213.  
  214.   /* Open our output file... Not settable... Always
  215.    * write to the root directory.  Simplistic, but
  216.    * gets the job done.
  217.    */
  218.   FILE *inputFile = fopen(DUMP_FILE, "rb");
  219.  
  220.   /*
  221.    * Inform our application that we are getting ready
  222.    * to transfer images.
  223.    */
  224.   (*twSession->transferFunctions->preTxfrCb)(NULL);
  225.  
  226.   /* Read the image information */
  227.   fread((void *) &imageInfo, sizeof(TW_IMAGEINFO), 1, inputFile);
  228.  
  229.   /* Call the begin transfer callback */
  230.   if (!(*twSession->transferFunctions->txfrBeginCb)(&imageInfo, twSession->clientData))
  231.     return;
  232.  
  233.   /* Read all of the data packets */
  234.   fread((void *) &moreData, sizeof(int), 1, inputFile);
  235.   while (moreData) {
  236.     /* Read the memory information */
  237.     fread((void *) &imageMemXfer, sizeof(TW_IMAGEMEMXFER), 1, inputFile);
  238.     imageMemXfer.Memory.TheMem = (TW_MEMREF) g_malloc (imageMemXfer.BytesWritten);
  239.     fread((void *) imageMemXfer.Memory.TheMem,
  240.       1, imageMemXfer.BytesWritten, inputFile);
  241.  
  242.     /* Call the data transfer callback function */
  243.     if (!(*twSession->transferFunctions->txfrDataCb) 
  244.     (&imageInfo, 
  245.      &imageMemXfer,    
  246.      twSession->clientData))
  247.       return;
  248.  
  249.     /* Clean up the memory */
  250.     g_free (imageMemXfer.Memory.TheMem);
  251.  
  252.     /* Check for continuation */
  253.     fread((void *) &moreData, sizeof(int), 1, inputFile);
  254.   }
  255.  
  256.   /* Grab the final information */
  257.   fread(&completionState, sizeof(int), 1, inputFile);
  258.   fread(&pendingCount, sizeof(int), 1, inputFile);
  259.  
  260.   if (twSession->transferFunctions->txfrEndCb)
  261.     (*twSession->transferFunctions->txfrEndCb)(completionState, 0,
  262.                            twSession->clientData);
  263.  
  264.   /* Post a message to close up the application */
  265.   PostQuitMessage(0);
  266. }
  267.