/*
 * TWAIN Plug-in
 * Copyright (C) 1999 Craig Setera
 * Craig Setera <setera@home.com>
 * 03/31/1999
 *
 * Updated for Mac OS X support
 * Brion Vibber <brion@pobox.com>
 * 07/22/2004
 *
 * 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 3 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, see <https://www.gnu.org/licenses/>.
 *
 *
 * Based on (at least) the following plug-ins:
 * Screenshot
 * GIF
 * Randomize
 *
 * Any suggestions, bug-reports or patches are welcome.
 *
 * This plug-in interfaces to the TWAIN support library in order
 * to capture images from TWAIN devices directly into GIMP images.
 * The plug-in is capable of acquiring the following type of
 * images:
 * - B/W (1 bit images translated to grayscale B/W)
 * - Grayscale up to 16 bits per pixel
 * - RGB up to 16 bits per sample (24, 30, 36, etc.)
 * - Paletted images (both Gray and RGB)
 *
 * Prerequisites:
 * Should compile and run on both Win32 and Mac OS X 10.3 (possibly
 * also on 10.2).
 *
 * Known problems:
 * - Multiple image transfers will hang the plug-in.  The current
 *   configuration compiles with a maximum of single image transfers.
 * - On Mac OS X, canceling doesn't always close things out fully.
 * - Epson TWAIN driver on Mac OS X crashes the plugin when scanning.
 */

/*
 * Revision history
 *  (02/07/99)  v0.1   First working version (internal)
 *  (02/09/99)  v0.2   First release to anyone other than myself
 *  (02/15/99)  v0.3   Added image dump and read support for debugging
 *  (03/31/99)  v0.5   Added support for multi-byte samples and paletted
 *                     images.
 *  (07/23/04)  v0.6   Added Mac OS X support.
 */

#include "config.h"

#include <string.h>

#include <glib/gstdio.h>

#include "libgimp/gimp.h"

#include "tw_dump.h"
#include "tw_func.h"
#include "tw_util.h"

/* File variables */
static FILE *outputFile = NULL;
extern pTW_SESSION twSession;

/*
 * dumpPreTransferCallback
 *
 * This callback function is called before any images
 * are transferred.  Set up the one time only stuff.
 */
void
dumpPreTransferCallback(void *clientData)
{
  /* Open our output file... Not settable... Always
   * write to the root directory.  Simplistic, but
   * gets the job done.
   */
  outputFile = g_fopen(DUMP_FILE, "wb");
}

/*
 * dumpBeginTransferCallback
 *
 * The following function is called at the beginning
 * of each image transfer.
 */
int
dumpBeginTransferCallback(pTW_IMAGEINFO imageInfo, void *clientData)
{
  logBegin(imageInfo, clientData);

  /* Dump the image information */
  fwrite((void *) imageInfo, sizeof(TW_IMAGEINFO), 1, outputFile);

  /* Keep going */
  return TRUE;
}

/*
 * dumpDataTransferCallback
 *
 * The following function is called for each memory
 * block that is transferred from the data source.
 */
int
dumpDataTransferCallback(pTW_IMAGEINFO imageInfo,
    pTW_IMAGEMEMXFER imageMemXfer,
    void *clientData)
{
  int flag = 1;

  logData(imageInfo, imageMemXfer, clientData);

  /* Write a flag that says that this is a data packet */
  fwrite((void *) &flag, sizeof(int), 1, outputFile);

  /* Dump the memory information */
  fwrite((void *) imageMemXfer, sizeof(TW_IMAGEMEMXFER), 1, outputFile);
  fwrite((void *) imageMemXfer->Memory.TheMem,
  1, imageMemXfer->BytesWritten, outputFile);

  /* Keep going */
  return TRUE;
}

/*
 * dumpEndTransferCallback
 *
 * The following function is called at the end of the
 * image transfer.  The caller will be handed
 * the image transfer completion state.  The
 * following values (defined in twain.h) are
 * possible:
 *
 * TWRC_XFERDONE
 *  The transfer completed successfully
 * TWRC_CANCEL
 *  The transfer was completed by the user
 * TWRC_FAILURE
 *  The transfer failed.
 */
int
dumpEndTransferCallback(int completionState, int pendingCount, void *clientData)
{
  int flag = 0;

  /* Write a flag that says that this is a data packet */
  fwrite((void *) &flag, sizeof(int), 1, outputFile);

  /* Write the necessary data */
  fwrite(&completionState, sizeof(int), 1, outputFile);
  fwrite(&pendingCount, sizeof(int), 1, outputFile);

  /* Only ever transfer a single image */
  return FALSE;
}

/*
 * dumpPostTransferCallback
 *
 * This callback function will be called
 * after all possible images have been
 * transferred.
 */
void
dumpPostTransferCallback(int pendingCount, void *clientData)
{
  char buffer[128];

  /* Shut things down. */
  if (pendingCount != 0)
    cancelPendingTransfers(twSession);

  /* This will close the datasource and datasource
   * manager.  Then the message queue will be shut
   * down and the run() procedure will finally be
   * able to finish.
   */
  disableDS(twSession);
  closeDS(twSession);
  closeDSM(twSession);

  /* Close the dump file */
  fclose(outputFile);

  /* Tell the user */
  sprintf(buffer, "Image dumped to file %s\n", DUMP_FILE);
  gimp_message(buffer);

  /* Post a message to close up the application */
  twainQuitApplication ();
}

/*
 * readDumpedImage
 *
 * Get a previously dumped image.
 */
void readDumpedImage(pTW_SESSION twSession)
{
  int moreData;
  int completionState;
  int pendingCount;

  TW_IMAGEINFO imageInfo;
  TW_IMAGEMEMXFER imageMemXfer;

  /* Open our output file... Not settable... Always
   * write to the root directory.  Simplistic, but
   * gets the job done.
   */
  FILE *inputFile = g_fopen(DUMP_FILE, "rb");

  /*
   * Inform our application that we are getting ready
   * to transfer images.
   */
  (*twSession->transferFunctions->preTxfrCb)(NULL);

  /* Read the image information */
  fread((void *) &imageInfo, sizeof(TW_IMAGEINFO), 1, inputFile);

  /* Call the begin transfer callback */
  if (!(*twSession->transferFunctions->txfrBeginCb)(&imageInfo, twSession->clientData))
    return;

  /* Read all of the data packets */
  fread((void *) &moreData, sizeof(int), 1, inputFile);
  while (moreData) {
    /* Read the memory information */
    fread((void *) &imageMemXfer, sizeof(TW_IMAGEMEMXFER), 1, inputFile);
    imageMemXfer.Memory.TheMem = (TW_MEMREF) g_malloc (imageMemXfer.BytesWritten);
    fread((void *) imageMemXfer.Memory.TheMem,
   1, imageMemXfer.BytesWritten, inputFile);

    /* Call the data transfer callback function */
    if (!(*twSession->transferFunctions->txfrDataCb)
 (&imageInfo,
  &imageMemXfer,
  twSession->clientData))
      return;

    /* Clean up the memory */
    g_free (imageMemXfer.Memory.TheMem);

    /* Check for continuation */
    fread((void *) &moreData, sizeof(int), 1, inputFile);
  }

  /* Grab the final information */
  fread(&completionState, sizeof(int), 1, inputFile);
  fread(&pendingCount, sizeof(int), 1, inputFile);

  if (twSession->transferFunctions->txfrEndCb)
    (*twSession->transferFunctions->txfrEndCb)(completionState, 0,
            twSession->clientData);

  /* Post a message to close up the application */
  twainQuitApplication ();
}