fix various divisions, tail calls etc.

24 files changed, 5231 insertions, 5190 deletions

diff --git a/test/monniaux/jpeg-6b/Makefile b/test/monniaux/jpeg-6b/Makefile
index bd0a737b..627161f0 100644
--- a/test/monniaux/jpeg-6b/Makefile
+++ b/test/monniaux/jpeg-6b/Makefile
@@ -7,6 +7,8 @@
 
 # The name of your C compiler:
 # CC= ../../../ccomp
+# GCC=k1-mbr-gcc
+GCC=$(CC)
 
 # You may need to adjust these cc options:
 CFLAGS= -O3 -Wall
@@ -109,6 +111,39 @@ all: libjpeg.a cjpeg djpeg jpegtran rdjpgcom wrjpgcom
 # 	$(RM) T$*.c $*.o
 # 	$(MV) T$*.o $*.o
 
+%.i : %.c
+	$(CC) $(CFLAGS) -E $< -o $@
+
+wrjpgcom.o : wrjpgcom.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+rdjpgcom.o : rdjpgcom.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+rdswitch.o : rdswitch.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+rdgif.o : rdgif.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+jmemmgr.o : jmemmgr.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+jerror.o : jerror.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+example.o : example.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+cjpeg.o : cjpeg.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+cdjpeg.o : cdjpeg.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
+djpeg.o : djpeg.c
+	$(GCC) $(CFLAGS) -c $< -o $@
+
 ansi2knr: ansi2knr.c
 	$(CC) $(CFLAGS) $(ANSI2KNRFLAGS) -o ansi2knr ansi2knr.c
 
diff --git a/test/monniaux/jpeg-6b/cdjpeg.c b/test/monniaux/jpeg-6b/cdjpeg.c
index b6250ff9..89fe6337 100644
--- a/test/monniaux/jpeg-6b/cdjpeg.c
+++ b/test/monniaux/jpeg-6b/cdjpeg.c
@@ -1,181 +1,181 @@
-/*
- * cdjpeg.c
- *
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains common support routines used by the IJG application
- * programs (cjpeg, djpeg, jpegtran).
- */
-
-#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */
-#include <ctype.h>		/* to declare isupper(), tolower() */
-#ifdef NEED_SIGNAL_CATCHER
-#include <signal.h>		/* to declare signal() */
-#endif
-#ifdef USE_SETMODE
-#include <fcntl.h>		/* to declare setmode()'s parameter macros */
-/* If you have setmode() but not <io.h>, just delete this line: */
-#include <io.h>			/* to declare setmode() */
-#endif
-
-
-/*
- * Signal catcher to ensure that temporary files are removed before aborting.
- * NB: for Amiga Manx C this is actually a global routine named _abort();
- * we put "#define signal_catcher _abort" in jconfig.h.  Talk about bogus...
- */
-
-#ifdef NEED_SIGNAL_CATCHER
-
-static j_common_ptr sig_cinfo;
-
-void				/* must be global for Manx C */
-signal_catcher (int signum)
-{
-  if (sig_cinfo != NULL) {
-    if (sig_cinfo->err != NULL) /* turn off trace output */
-      sig_cinfo->err->trace_level = 0;
-    jpeg_destroy(sig_cinfo);	/* clean up memory allocation & temp files */
-  }
-  exit(EXIT_FAILURE);
-}
-
-
-GLOBAL(void)
-enable_signal_catcher (j_common_ptr cinfo)
-{
-  sig_cinfo = cinfo;
-#ifdef SIGINT			/* not all systems have SIGINT */
-  signal(SIGINT, signal_catcher);
-#endif
-#ifdef SIGTERM			/* not all systems have SIGTERM */
-  signal(SIGTERM, signal_catcher);
-#endif
-}
-
-#endif
-
-
-/*
- * Optional progress monitor: display a percent-done figure on stderr.
- */
-
-#ifdef PROGRESS_REPORT
-
-METHODDEF(void)
-progress_monitor (j_common_ptr cinfo)
-{
-  cd_progress_ptr prog = (cd_progress_ptr) cinfo->progress;
-  int total_passes = prog->pub.total_passes + prog->total_extra_passes;
-  int percent_done = (int) (prog->pub.pass_counter*100L/prog->pub.pass_limit);
-
-  if (percent_done != prog->percent_done) {
-    prog->percent_done = percent_done;
-    if (total_passes > 1) {
-      fprintf(stderr, "\rPass %d/%d: %3d%% ",
-	      prog->pub.completed_passes + prog->completed_extra_passes + 1,
-	      total_passes, percent_done);
-    } else {
-      fprintf(stderr, "\r %3d%% ", percent_done);
-    }
-    fflush(stderr);
-  }
-}
-
-
-GLOBAL(void)
-start_progress_monitor (j_common_ptr cinfo, cd_progress_ptr progress)
-{
-  /* Enable progress display, unless trace output is on */
-  if (cinfo->err->trace_level == 0) {
-    progress->pub.progress_monitor = progress_monitor;
-    progress->completed_extra_passes = 0;
-    progress->total_extra_passes = 0;
-    progress->percent_done = -1;
-    cinfo->progress = &progress->pub;
-  }
-}
-
-
-GLOBAL(void)
-end_progress_monitor (j_common_ptr cinfo)
-{
-  /* Clear away progress display */
-  if (cinfo->err->trace_level == 0) {
-    fprintf(stderr, "\r                \r");
-    fflush(stderr);
-  }
-}
-
-#endif
-
-
-/*
- * Case-insensitive matching of possibly-abbreviated keyword switches.
- * keyword is the constant keyword (must be lower case already),
- * minchars is length of minimum legal abbreviation.
- */
-
-GLOBAL(boolean)
-keymatch (char * arg, const char * keyword, int minchars)
-{
-  register int ca, ck;
-  register int nmatched = 0;
-
-  while ((ca = *arg++) != '\0') {
-    if ((ck = *keyword++) == '\0')
-      return FALSE;		/* arg longer than keyword, no good */
-    if (isupper(ca))		/* force arg to lcase (assume ck is already) */
-      ca = tolower(ca);
-    if (ca != ck)
-      return FALSE;		/* no good */
-    nmatched++;			/* count matched characters */
-  }
-  /* reached end of argument; fail if it's too short for unique abbrev */
-  if (nmatched < minchars)
-    return FALSE;
-  return TRUE;			/* A-OK */
-}
-
-
-/*
- * Routines to establish binary I/O mode for stdin and stdout.
- * Non-Unix systems often require some hacking to get out of text mode.
- */
-
-GLOBAL(FILE *)
-read_stdin (void)
-{
-  FILE * input_file = stdin;
-
-#ifdef USE_SETMODE		/* need to hack file mode? */
-  setmode(fileno(stdin), O_BINARY);
-#endif
-#ifdef USE_FDOPEN		/* need to re-open in binary mode? */
-  if ((input_file = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
-    fprintf(stderr, "Cannot reopen stdin\n");
-    exit(EXIT_FAILURE);
-  }
-#endif
-  return input_file;
-}
-
-
-GLOBAL(FILE *)
-write_stdout (void)
-{
-  FILE * output_file = stdout;
-
-#ifdef USE_SETMODE		/* need to hack file mode? */
-  setmode(fileno(stdout), O_BINARY);
-#endif
-#ifdef USE_FDOPEN		/* need to re-open in binary mode? */
-  if ((output_file = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {
-    fprintf(stderr, "Cannot reopen stdout\n");
-    exit(EXIT_FAILURE);
-  }
-#endif
-  return output_file;
-}
+/*

+ * cdjpeg.c

+ *

+ * Copyright (C) 1991-1997, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains common support routines used by the IJG application

+ * programs (cjpeg, djpeg, jpegtran).

+ */

+

+#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */

+#include <ctype.h>		/* to declare isupper(), tolower() */

+#ifdef NEED_SIGNAL_CATCHER

+#include <signal.h>		/* to declare signal() */

+#endif

+#ifdef USE_SETMODE

+#include <fcntl.h>		/* to declare setmode()'s parameter macros */

+/* If you have setmode() but not <io.h>, just delete this line: */

+#include <io.h>			/* to declare setmode() */

+#endif

+

+

+/*

+ * Signal catcher to ensure that temporary files are removed before aborting.

+ * NB: for Amiga Manx C this is actually a global routine named _abort();

+ * we put "#define signal_catcher _abort" in jconfig.h.  Talk about bogus...

+ */

+

+#ifdef NEED_SIGNAL_CATCHER

+

+static j_common_ptr sig_cinfo;

+

+void				/* must be global for Manx C */

+signal_catcher (int signum)

+{

+  if (sig_cinfo != NULL) {

+    if (sig_cinfo->err != NULL) /* turn off trace output */

+      sig_cinfo->err->trace_level = 0;

+    jpeg_destroy(sig_cinfo);	/* clean up memory allocation & temp files */

+  }

+  exit(EXIT_FAILURE);

+}

+

+

+GLOBAL(void)

+enable_signal_catcher (j_common_ptr cinfo)

+{

+  sig_cinfo = cinfo;

+#ifdef SIGINT			/* not all systems have SIGINT */

+  signal(SIGINT, signal_catcher);

+#endif

+#ifdef SIGTERM			/* not all systems have SIGTERM */

+  signal(SIGTERM, signal_catcher);

+#endif

+}

+

+#endif

+

+

+/*

+ * Optional progress monitor: display a percent-done figure on stderr.

+ */

+

+#ifdef PROGRESS_REPORT

+

+METHODDEF(void)

+progress_monitor (j_common_ptr cinfo)

+{

+  cd_progress_ptr prog = (cd_progress_ptr) cinfo->progress;

+  int total_passes = prog->pub.total_passes + prog->total_extra_passes;

+  int percent_done = (int) (prog->pub.pass_counter*100L/prog->pub.pass_limit);

+

+  if (percent_done != prog->percent_done) {

+    prog->percent_done = percent_done;

+    if (total_passes > 1) {

+      fprintf(stderr, "\rPass %d/%d: %3d%% ",

+	      prog->pub.completed_passes + prog->completed_extra_passes + 1,

+	      total_passes, percent_done);

+    } else {

+      fprintf(stderr, "\r %3d%% ", percent_done);

+    }

+    fflush(stderr);

+  }

+}

+

+

+GLOBAL(void)

+start_progress_monitor (j_common_ptr cinfo, cd_progress_ptr progress)

+{

+  /* Enable progress display, unless trace output is on */

+  if (cinfo->err->trace_level == 0) {

+    progress->pub.progress_monitor = progress_monitor;

+    progress->completed_extra_passes = 0;

+    progress->total_extra_passes = 0;

+    progress->percent_done = -1;

+    cinfo->progress = &progress->pub;

+  }

+}

+

+

+GLOBAL(void)

+end_progress_monitor (j_common_ptr cinfo)

+{

+  /* Clear away progress display */

+  if (cinfo->err->trace_level == 0) {

+    fprintf(stderr, "\r                \r");

+    fflush(stderr);

+  }

+}

+

+#endif

+

+

+/*

+ * Case-insensitive matching of possibly-abbreviated keyword switches.

+ * keyword is the constant keyword (must be lower case already),

+ * minchars is length of minimum legal abbreviation.

+ */

+

+GLOBAL(boolean)

+keymatch (char * arg, const char * keyword, int minchars)

+{

+  register int ca, ck;

+  register int nmatched = 0;

+

+  while ((ca = *arg++) != '\0') {

+    if ((ck = *keyword++) == '\0')

+      return FALSE;		/* arg longer than keyword, no good */

+    if (isupper(ca))		/* force arg to lcase (assume ck is already) */

+      ca = tolower(ca);

+    if (ca != ck)

+      return FALSE;		/* no good */

+    nmatched++;			/* count matched characters */

+  }

+  /* reached end of argument; fail if it's too short for unique abbrev */

+  if (nmatched < minchars)

+    return FALSE;

+  return TRUE;			/* A-OK */

+}

+

+

+/*

+ * Routines to establish binary I/O mode for stdin and stdout.

+ * Non-Unix systems often require some hacking to get out of text mode.

+ */

+

+GLOBAL(FILE *)

+read_stdin (void)

+{

+  FILE * input_file = stdin;

+

+#ifdef USE_SETMODE		/* need to hack file mode? */

+  setmode(fileno(stdin), O_BINARY);

+#endif

+#ifdef USE_FDOPEN		/* need to re-open in binary mode? */

+  if ((input_file = fdopen(fileno(stdin), READ_BINARY)) == NULL) {

+    fprintf(stderr, "Cannot reopen stdin\n");

+    exit(EXIT_FAILURE);

+  }

+#endif

+  return input_file;

+}

+

+

+GLOBAL(FILE *)

+write_stdout (void)

+{

+  FILE * output_file = stdout;

+

+#ifdef USE_SETMODE		/* need to hack file mode? */

+  setmode(fileno(stdout), O_BINARY);

+#endif

+#ifdef USE_FDOPEN		/* need to re-open in binary mode? */

+  if ((output_file = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {

+    fprintf(stderr, "Cannot reopen stdout\n");

+    exit(EXIT_FAILURE);

+  }

+#endif

+  return output_file;

+}

diff --git a/test/monniaux/jpeg-6b/cjpeg.c b/test/monniaux/jpeg-6b/cjpeg.c
index f2a929f0..b9102ee9 100644
--- a/test/monniaux/jpeg-6b/cjpeg.c
+++ b/test/monniaux/jpeg-6b/cjpeg.c
@@ -1,606 +1,606 @@
-/*
- * cjpeg.c
- *
- * Copyright (C) 1991-1998, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains a command-line user interface for the JPEG compressor.
- * It should work on any system with Unix- or MS-DOS-style command lines.
- *
- * Two different command line styles are permitted, depending on the
- * compile-time switch TWO_FILE_COMMANDLINE:
- *	cjpeg [options]  inputfile outputfile
- *	cjpeg [options]  [inputfile]
- * In the second style, output is always to standard output, which you'd
- * normally redirect to a file or pipe to some other program.  Input is
- * either from a named file or from standard input (typically redirected).
- * The second style is convenient on Unix but is unhelpful on systems that
- * don't support pipes.  Also, you MUST use the first style if your system
- * doesn't do binary I/O to stdin/stdout.
- * To simplify script writing, the "-outfile" switch is provided.  The syntax
- *	cjpeg [options]  -outfile outputfile  inputfile
- * works regardless of which command line style is used.
- */
-
-#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */
-#include "jversion.h"		/* for version message */
-
-#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */
-#ifdef __MWERKS__
-#include <SIOUX.h>              /* Metrowerks needs this */
-#include <console.h>		/* ... and this */
-#endif
-#ifdef THINK_C
-#include <console.h>		/* Think declares it here */
-#endif
-#endif
-
-
-/* Create the add-on message string table. */
-
-#define JMESSAGE(code,string)	string ,
-
-static const char * const cdjpeg_message_table[] = {
-#include "cderror.h"
-  NULL
-};
-
-
-/*
- * This routine determines what format the input file is,
- * and selects the appropriate input-reading module.
- *
- * To determine which family of input formats the file belongs to,
- * we may look only at the first byte of the file, since C does not
- * guarantee that more than one character can be pushed back with ungetc.
- * Looking at additional bytes would require one of these approaches:
- *     1) assume we can fseek() the input file (fails for piped input);
- *     2) assume we can push back more than one character (works in
- *        some C implementations, but unportable);
- *     3) provide our own buffering (breaks input readers that want to use
- *        stdio directly, such as the RLE library);
- * or  4) don't put back the data, and modify the input_init methods to assume
- *        they start reading after the start of file (also breaks RLE library).
- * #1 is attractive for MS-DOS but is untenable on Unix.
- *
- * The most portable solution for file types that can't be identified by their
- * first byte is to make the user tell us what they are.  This is also the
- * only approach for "raw" file types that contain only arbitrary values.
- * We presently apply this method for Targa files.  Most of the time Targa
- * files start with 0x00, so we recognize that case.  Potentially, however,
- * a Targa file could start with any byte value (byte 0 is the length of the
- * seldom-used ID field), so we provide a switch to force Targa input mode.
- */
-
-static boolean is_targa;	/* records user -targa switch */
-
-
-LOCAL(cjpeg_source_ptr)
-select_file_type (j_compress_ptr cinfo, FILE * infile)
-{
-  int c;
-
-  if (is_targa) {
-#ifdef TARGA_SUPPORTED
-    return jinit_read_targa(cinfo);
-#else
-    ERREXIT(cinfo, JERR_TGA_NOTCOMP);
-#endif
-  }
-
-  if ((c = getc(infile)) == EOF)
-    ERREXIT(cinfo, JERR_INPUT_EMPTY);
-  if (ungetc(c, infile) == EOF)
-    ERREXIT(cinfo, JERR_UNGETC_FAILED);
-
-  switch (c) {
-#ifdef BMP_SUPPORTED
-  case 'B':
-    return jinit_read_bmp(cinfo);
-#endif
-#ifdef GIF_SUPPORTED
-  case 'G':
-    return jinit_read_gif(cinfo);
-#endif
-#ifdef PPM_SUPPORTED
-  case 'P':
-    return jinit_read_ppm(cinfo);
-#endif
-#ifdef RLE_SUPPORTED
-  case 'R':
-    return jinit_read_rle(cinfo);
-#endif
-#ifdef TARGA_SUPPORTED
-  case 0x00:
-    return jinit_read_targa(cinfo);
-#endif
-  default:
-    ERREXIT(cinfo, JERR_UNKNOWN_FORMAT);
-    break;
-  }
-
-  return NULL;			/* suppress compiler warnings */
-}
-
-
-/*
- * Argument-parsing code.
- * The switch parser is designed to be useful with DOS-style command line
- * syntax, ie, intermixed switches and file names, where only the switches
- * to the left of a given file name affect processing of that file.
- * The main program in this file doesn't actually use this capability...
- */
-
-
-static const char * progname;	/* program name for error messages */
-static char * outfilename;	/* for -outfile switch */
-
-
-LOCAL(void)
-usage (void)
-/* complain about bad command line */
-{
-  fprintf(stderr, "usage: %s [switches] ", progname);
-#ifdef TWO_FILE_COMMANDLINE
-  fprintf(stderr, "inputfile outputfile\n");
-#else
-  fprintf(stderr, "[inputfile]\n");
-#endif
-
-  fprintf(stderr, "Switches (names may be abbreviated):\n");
-  fprintf(stderr, "  -quality N     Compression quality (0..100; 5-95 is useful range)\n");
-  fprintf(stderr, "  -grayscale     Create monochrome JPEG file\n");
-#ifdef ENTROPY_OPT_SUPPORTED
-  fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)\n");
-#endif
-#ifdef C_PROGRESSIVE_SUPPORTED
-  fprintf(stderr, "  -progressive   Create progressive JPEG file\n");
-#endif
-#ifdef TARGA_SUPPORTED
-  fprintf(stderr, "  -targa         Input file is Targa format (usually not needed)\n");
-#endif
-  fprintf(stderr, "Switches for advanced users:\n");
-#ifdef DCT_ISLOW_SUPPORTED
-  fprintf(stderr, "  -dct int       Use integer DCT method%s\n",
-	  (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
-#endif
-#ifdef DCT_IFAST_SUPPORTED
-  fprintf(stderr, "  -dct fast      Use fast integer DCT (less accurate)%s\n",
-	  (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-  fprintf(stderr, "  -dct float     Use floating-point DCT method%s\n",
-	  (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
-#endif
-  fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with B\n");
-#ifdef INPUT_SMOOTHING_SUPPORTED
-  fprintf(stderr, "  -smooth N      Smooth dithered input (N=1..100 is strength)\n");
-#endif
-  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");
-  fprintf(stderr, "  -outfile name  Specify name for output file\n");
-  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");
-  fprintf(stderr, "Switches for wizards:\n");
-#ifdef C_ARITH_CODING_SUPPORTED
-  fprintf(stderr, "  -arithmetic    Use arithmetic coding\n");
-#endif
-  fprintf(stderr, "  -baseline      Force baseline quantization tables\n");
-  fprintf(stderr, "  -qtables file  Use quantization tables given in file\n");
-  fprintf(stderr, "  -qslots N[,...]    Set component quantization tables\n");
-  fprintf(stderr, "  -sample HxV[,...]  Set component sampling factors\n");
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-  fprintf(stderr, "  -scans file    Create multi-scan JPEG per script file\n");
-#endif
-  exit(EXIT_FAILURE);
-}
-
-
-LOCAL(int)
-parse_switches (j_compress_ptr cinfo, int argc, char **argv,
-		int last_file_arg_seen, boolean for_real)
-/* Parse optional switches.
- * Returns argv[] index of first file-name argument (== argc if none).
- * Any file names with indexes <= last_file_arg_seen are ignored;
- * they have presumably been processed in a previous iteration.
- * (Pass 0 for last_file_arg_seen on the first or only iteration.)
- * for_real is FALSE on the first (dummy) pass; we may skip any expensive
- * processing.
- */
-{
-  int argn;
-  char * arg;
-  int quality;			/* -quality parameter */
-  int q_scale_factor;		/* scaling percentage for -qtables */
-  boolean force_baseline;
-  boolean simple_progressive;
-  char * qtablefile = NULL;	/* saves -qtables filename if any */
-  char * qslotsarg = NULL;	/* saves -qslots parm if any */
-  char * samplearg = NULL;	/* saves -sample parm if any */
-  char * scansarg = NULL;	/* saves -scans parm if any */
-
-  /* Set up default JPEG parameters. */
-  /* Note that default -quality level need not, and does not,
-   * match the default scaling for an explicit -qtables argument.
-   */
-  quality = 75;			/* default -quality value */
-  q_scale_factor = 100;		/* default to no scaling for -qtables */
-  force_baseline = FALSE;	/* by default, allow 16-bit quantizers */
-  simple_progressive = FALSE;
-  is_targa = FALSE;
-  outfilename = NULL;
-  cinfo->err->trace_level = 0;
-
-  /* Scan command line options, adjust parameters */
-
-  for (argn = 1; argn < argc; argn++) {
-    arg = argv[argn];
-    if (*arg != '-') {
-      /* Not a switch, must be a file name argument */
-      if (argn <= last_file_arg_seen) {
-	outfilename = NULL;	/* -outfile applies to just one input file */
-	continue;		/* ignore this name if previously processed */
-      }
-      break;			/* else done parsing switches */
-    }
-    arg++;			/* advance past switch marker character */
-
-    if (keymatch(arg, "arithmetic", 1)) {
-      /* Use arithmetic coding. */
-#ifdef C_ARITH_CODING_SUPPORTED
-      cinfo->arith_code = TRUE;
-#else
-      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "baseline", 1)) {
-      /* Force baseline-compatible output (8-bit quantizer values). */
-      force_baseline = TRUE;
-
-    } else if (keymatch(arg, "dct", 2)) {
-      /* Select DCT algorithm. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (keymatch(argv[argn], "int", 1)) {
-	cinfo->dct_method = JDCT_ISLOW;
-      } else if (keymatch(argv[argn], "fast", 2)) {
-	cinfo->dct_method = JDCT_IFAST;
-      } else if (keymatch(argv[argn], "float", 2)) {
-	cinfo->dct_method = JDCT_FLOAT;
-      } else
-	usage();
-
-    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
-      /* Enable debug printouts. */
-      /* On first -d, print version identification */
-      static boolean printed_version = FALSE;
-
-      if (! printed_version) {
-	fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n",
-		JVERSION, JCOPYRIGHT);
-	printed_version = TRUE;
-      }
-      cinfo->err->trace_level++;
-
-    } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
-      /* Force a monochrome JPEG file to be generated. */
-      jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
-
-    } else if (keymatch(arg, "maxmemory", 3)) {
-      /* Maximum memory in Kb (or Mb with 'm'). */
-      long lval;
-      char ch = 'x';
-
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
-	usage();
-      if (ch == 'm' || ch == 'M')
-	lval *= 1000L;
-      cinfo->mem->max_memory_to_use = lval * 1000L;
-
-    } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
-      /* Enable entropy parm optimization. */
-#ifdef ENTROPY_OPT_SUPPORTED
-      cinfo->optimize_coding = TRUE;
-#else
-      fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "outfile", 4)) {
-      /* Set output file name. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      outfilename = argv[argn];	/* save it away for later use */
-
-    } else if (keymatch(arg, "progressive", 1)) {
-      /* Select simple progressive mode. */
-#ifdef C_PROGRESSIVE_SUPPORTED
-      simple_progressive = TRUE;
-      /* We must postpone execution until num_components is known. */
-#else
-      fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "quality", 1)) {
-      /* Quality factor (quantization table scaling factor). */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%d", &quality) != 1)
-	usage();
-      /* Change scale factor in case -qtables is present. */
-      q_scale_factor = jpeg_quality_scaling(quality);
-
-    } else if (keymatch(arg, "qslots", 2)) {
-      /* Quantization table slot numbers. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      qslotsarg = argv[argn];
-      /* Must delay setting qslots until after we have processed any
-       * colorspace-determining switches, since jpeg_set_colorspace sets
-       * default quant table numbers.
-       */
-
-    } else if (keymatch(arg, "qtables", 2)) {
-      /* Quantization tables fetched from file. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      qtablefile = argv[argn];
-      /* We postpone actually reading the file in case -quality comes later. */
-
-    } else if (keymatch(arg, "restart", 1)) {
-      /* Restart interval in MCU rows (or in MCUs with 'b'). */
-      long lval;
-      char ch = 'x';
-
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
-	usage();
-      if (lval < 0 || lval > 65535L)
-	usage();
-      if (ch == 'b' || ch == 'B') {
-	cinfo->restart_interval = (unsigned int) lval;
-	cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
-      } else {
-	cinfo->restart_in_rows = (int) lval;
-	/* restart_interval will be computed during startup */
-      }
-
-    } else if (keymatch(arg, "sample", 2)) {
-      /* Set sampling factors. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      samplearg = argv[argn];
-      /* Must delay setting sample factors until after we have processed any
-       * colorspace-determining switches, since jpeg_set_colorspace sets
-       * default sampling factors.
-       */
-
-    } else if (keymatch(arg, "scans", 2)) {
-      /* Set scan script. */
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      scansarg = argv[argn];
-      /* We must postpone reading the file in case -progressive appears. */
-#else
-      fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "smooth", 2)) {
-      /* Set input smoothing factor. */
-      int val;
-
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%d", &val) != 1)
-	usage();
-      if (val < 0 || val > 100)
-	usage();
-      cinfo->smoothing_factor = val;
-
-    } else if (keymatch(arg, "targa", 1)) {
-      /* Input file is Targa format. */
-      is_targa = TRUE;
-
-    } else {
-      usage();			/* bogus switch */
-    }
-  }
-
-  /* Post-switch-scanning cleanup */
-
-  if (for_real) {
-
-    /* Set quantization tables for selected quality. */
-    /* Some or all may be overridden if -qtables is present. */
-    jpeg_set_quality(cinfo, quality, force_baseline);
-
-    if (qtablefile != NULL)	/* process -qtables if it was present */
-      if (! read_quant_tables(cinfo, qtablefile,
-			      q_scale_factor, force_baseline))
-	usage();
-
-    if (qslotsarg != NULL)	/* process -qslots if it was present */
-      if (! set_quant_slots(cinfo, qslotsarg))
-	usage();
-
-    if (samplearg != NULL)	/* process -sample if it was present */
-      if (! set_sample_factors(cinfo, samplearg))
-	usage();
-
-#ifdef C_PROGRESSIVE_SUPPORTED
-    if (simple_progressive)	/* process -progressive; -scans can override */
-      jpeg_simple_progression(cinfo);
-#endif
-
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-    if (scansarg != NULL)	/* process -scans if it was present */
-      if (! read_scan_script(cinfo, scansarg))
-	usage();
-#endif
-  }
-
-  return argn;			/* return index of next arg (file name) */
-}
-
-
-/*
- * The main program.
- */
-
-int
-main (int argc, char **argv)
-{
-  struct jpeg_compress_struct cinfo;
-  struct jpeg_error_mgr jerr;
-#ifdef PROGRESS_REPORT
-  struct cdjpeg_progress_mgr progress;
-#endif
-  int file_index;
-  cjpeg_source_ptr src_mgr;
-  FILE * input_file;
-  FILE * output_file;
-  JDIMENSION num_scanlines;
-
-  /* On Mac, fetch a command line. */
-#ifdef USE_CCOMMAND
-  argc = ccommand(&argv);
-#endif
-
-  progname = argv[0];
-  if (progname == NULL || progname[0] == 0)
-    progname = "cjpeg";		/* in case C library doesn't provide it */
-
-  /* Initialize the JPEG compression object with default error handling. */
-  cinfo.err = jpeg_std_error(&jerr);
-  jpeg_create_compress(&cinfo);
-  /* Add some application-specific error messages (from cderror.h) */
-  jerr.addon_message_table = cdjpeg_message_table;
-  jerr.first_addon_message = JMSG_FIRSTADDONCODE;
-  jerr.last_addon_message = JMSG_LASTADDONCODE;
-
-  /* Now safe to enable signal catcher. */
-#ifdef NEED_SIGNAL_CATCHER
-  enable_signal_catcher((j_common_ptr) &cinfo);
-#endif
-
-  /* Initialize JPEG parameters.
-   * Much of this may be overridden later.
-   * In particular, we don't yet know the input file's color space,
-   * but we need to provide some value for jpeg_set_defaults() to work.
-   */
-
-  cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
-  jpeg_set_defaults(&cinfo);
-
-  /* Scan command line to find file names.
-   * It is convenient to use just one switch-parsing routine, but the switch
-   * values read here are ignored; we will rescan the switches after opening
-   * the input file.
-   */
-
-  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
-
-#ifdef TWO_FILE_COMMANDLINE
-  /* Must have either -outfile switch or explicit output file name */
-  if (outfilename == NULL) {
-    if (file_index != argc-2) {
-      fprintf(stderr, "%s: must name one input and one output file\n",
-	      progname);
-      usage();
-    }
-    outfilename = argv[file_index+1];
-  } else {
-    if (file_index != argc-1) {
-      fprintf(stderr, "%s: must name one input and one output file\n",
-	      progname);
-      usage();
-    }
-  }
-#else
-  /* Unix style: expect zero or one file name */
-  if (file_index < argc-1) {
-    fprintf(stderr, "%s: only one input file\n", progname);
-    usage();
-  }
-#endif /* TWO_FILE_COMMANDLINE */
-
-  /* Open the input file. */
-  if (file_index < argc) {
-    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default input file is stdin */
-    input_file = read_stdin();
-  }
-
-  /* Open the output file. */
-  if (outfilename != NULL) {
-    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default output file is stdout */
-    output_file = write_stdout();
-  }
-
-#ifdef PROGRESS_REPORT
-  start_progress_monitor((j_common_ptr) &cinfo, &progress);
-#endif
-
-  /* Figure out the input file format, and set up to read it. */
-  src_mgr = select_file_type(&cinfo, input_file);
-  src_mgr->input_file = input_file;
-
-  /* Read the input file header to obtain file size & colorspace. */
-  (*src_mgr->start_input) (&cinfo, src_mgr);
-
-  /* Now that we know input colorspace, fix colorspace-dependent defaults */
-  jpeg_default_colorspace(&cinfo);
-
-  /* Adjust default compression parameters by re-parsing the options */
-  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
-
-  /* Specify data destination for compression */
-  jpeg_stdio_dest(&cinfo, output_file);
-
-  /* Start compressor */
-  jpeg_start_compress(&cinfo, TRUE);
-
-  /* Process data */
-  while (cinfo.next_scanline < cinfo.image_height) {
-    num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
-    (void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
-  }
-
-  /* Finish compression and release memory */
-  (*src_mgr->finish_input) (&cinfo, src_mgr);
-  jpeg_finish_compress(&cinfo);
-  jpeg_destroy_compress(&cinfo);
-
-  /* Close files, if we opened them */
-  if (input_file != stdin)
-    fclose(input_file);
-  if (output_file != stdout)
-    fclose(output_file);
-
-#ifdef PROGRESS_REPORT
-  end_progress_monitor((j_common_ptr) &cinfo);
-#endif
-
-  /* All done. */
-  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
-  return 0;			/* suppress no-return-value warnings */
-}
+/*

+ * cjpeg.c

+ *

+ * Copyright (C) 1991-1998, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains a command-line user interface for the JPEG compressor.

+ * It should work on any system with Unix- or MS-DOS-style command lines.

+ *

+ * Two different command line styles are permitted, depending on the

+ * compile-time switch TWO_FILE_COMMANDLINE:

+ *	cjpeg [options]  inputfile outputfile

+ *	cjpeg [options]  [inputfile]

+ * In the second style, output is always to standard output, which you'd

+ * normally redirect to a file or pipe to some other program.  Input is

+ * either from a named file or from standard input (typically redirected).

+ * The second style is convenient on Unix but is unhelpful on systems that

+ * don't support pipes.  Also, you MUST use the first style if your system

+ * doesn't do binary I/O to stdin/stdout.

+ * To simplify script writing, the "-outfile" switch is provided.  The syntax

+ *	cjpeg [options]  -outfile outputfile  inputfile

+ * works regardless of which command line style is used.

+ */

+

+#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */

+#include "jversion.h"		/* for version message */

+

+#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */

+#ifdef __MWERKS__

+#include <SIOUX.h>              /* Metrowerks needs this */

+#include <console.h>		/* ... and this */

+#endif

+#ifdef THINK_C

+#include <console.h>		/* Think declares it here */

+#endif

+#endif

+

+

+/* Create the add-on message string table. */

+

+#define JMESSAGE(code,string)	string ,

+

+static const char * const cdjpeg_message_table[] = {

+#include "cderror.h"

+  NULL

+};

+

+

+/*

+ * This routine determines what format the input file is,

+ * and selects the appropriate input-reading module.

+ *

+ * To determine which family of input formats the file belongs to,

+ * we may look only at the first byte of the file, since C does not

+ * guarantee that more than one character can be pushed back with ungetc.

+ * Looking at additional bytes would require one of these approaches:

+ *     1) assume we can fseek() the input file (fails for piped input);

+ *     2) assume we can push back more than one character (works in

+ *        some C implementations, but unportable);

+ *     3) provide our own buffering (breaks input readers that want to use

+ *        stdio directly, such as the RLE library);

+ * or  4) don't put back the data, and modify the input_init methods to assume

+ *        they start reading after the start of file (also breaks RLE library).

+ * #1 is attractive for MS-DOS but is untenable on Unix.

+ *

+ * The most portable solution for file types that can't be identified by their

+ * first byte is to make the user tell us what they are.  This is also the

+ * only approach for "raw" file types that contain only arbitrary values.

+ * We presently apply this method for Targa files.  Most of the time Targa

+ * files start with 0x00, so we recognize that case.  Potentially, however,

+ * a Targa file could start with any byte value (byte 0 is the length of the

+ * seldom-used ID field), so we provide a switch to force Targa input mode.

+ */

+

+static boolean is_targa;	/* records user -targa switch */

+

+

+LOCAL(cjpeg_source_ptr)

+select_file_type (j_compress_ptr cinfo, FILE * infile)

+{

+  int c;

+

+  if (is_targa) {

+#ifdef TARGA_SUPPORTED

+    return jinit_read_targa(cinfo);

+#else

+    ERREXIT(cinfo, JERR_TGA_NOTCOMP);

+#endif

+  }

+

+  if ((c = getc(infile)) == EOF)

+    ERREXIT(cinfo, JERR_INPUT_EMPTY);

+  if (ungetc(c, infile) == EOF)

+    ERREXIT(cinfo, JERR_UNGETC_FAILED);

+

+  switch (c) {

+#ifdef BMP_SUPPORTED

+  case 'B':

+    return jinit_read_bmp(cinfo);

+#endif

+#ifdef GIF_SUPPORTED

+  case 'G':

+    return jinit_read_gif(cinfo);

+#endif

+#ifdef PPM_SUPPORTED

+  case 'P':

+    return jinit_read_ppm(cinfo);

+#endif

+#ifdef RLE_SUPPORTED

+  case 'R':

+    return jinit_read_rle(cinfo);

+#endif

+#ifdef TARGA_SUPPORTED

+  case 0x00:

+    return jinit_read_targa(cinfo);

+#endif

+  default:

+    ERREXIT(cinfo, JERR_UNKNOWN_FORMAT);

+    break;

+  }

+

+  return NULL;			/* suppress compiler warnings */

+}

+

+

+/*

+ * Argument-parsing code.

+ * The switch parser is designed to be useful with DOS-style command line

+ * syntax, ie, intermixed switches and file names, where only the switches

+ * to the left of a given file name affect processing of that file.

+ * The main program in this file doesn't actually use this capability...

+ */

+

+

+static const char * progname;	/* program name for error messages */

+static char * outfilename;	/* for -outfile switch */

+

+

+LOCAL(void)

+usage (void)

+/* complain about bad command line */

+{

+  fprintf(stderr, "usage: %s [switches] ", progname);

+#ifdef TWO_FILE_COMMANDLINE

+  fprintf(stderr, "inputfile outputfile\n");

+#else

+  fprintf(stderr, "[inputfile]\n");

+#endif

+

+  fprintf(stderr, "Switches (names may be abbreviated):\n");

+  fprintf(stderr, "  -quality N     Compression quality (0..100; 5-95 is useful range)\n");

+  fprintf(stderr, "  -grayscale     Create monochrome JPEG file\n");

+#ifdef ENTROPY_OPT_SUPPORTED

+  fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)\n");

+#endif

+#ifdef C_PROGRESSIVE_SUPPORTED

+  fprintf(stderr, "  -progressive   Create progressive JPEG file\n");

+#endif

+#ifdef TARGA_SUPPORTED

+  fprintf(stderr, "  -targa         Input file is Targa format (usually not needed)\n");

+#endif

+  fprintf(stderr, "Switches for advanced users:\n");

+#ifdef DCT_ISLOW_SUPPORTED

+  fprintf(stderr, "  -dct int       Use integer DCT method%s\n",

+	  (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));

+#endif

+#ifdef DCT_IFAST_SUPPORTED

+  fprintf(stderr, "  -dct fast      Use fast integer DCT (less accurate)%s\n",

+	  (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));

+#endif

+#ifdef DCT_FLOAT_SUPPORTED

+  fprintf(stderr, "  -dct float     Use floating-point DCT method%s\n",

+	  (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));

+#endif

+  fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with B\n");

+#ifdef INPUT_SMOOTHING_SUPPORTED

+  fprintf(stderr, "  -smooth N      Smooth dithered input (N=1..100 is strength)\n");

+#endif

+  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");

+  fprintf(stderr, "  -outfile name  Specify name for output file\n");

+  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");

+  fprintf(stderr, "Switches for wizards:\n");

+#ifdef C_ARITH_CODING_SUPPORTED

+  fprintf(stderr, "  -arithmetic    Use arithmetic coding\n");

+#endif

+  fprintf(stderr, "  -baseline      Force baseline quantization tables\n");

+  fprintf(stderr, "  -qtables file  Use quantization tables given in file\n");

+  fprintf(stderr, "  -qslots N[,...]    Set component quantization tables\n");

+  fprintf(stderr, "  -sample HxV[,...]  Set component sampling factors\n");

+#ifdef C_MULTISCAN_FILES_SUPPORTED

+  fprintf(stderr, "  -scans file    Create multi-scan JPEG per script file\n");

+#endif

+  exit(EXIT_FAILURE);

+}

+

+

+LOCAL(int)

+parse_switches (j_compress_ptr cinfo, int argc, char **argv,

+		int last_file_arg_seen, boolean for_real)

+/* Parse optional switches.

+ * Returns argv[] index of first file-name argument (== argc if none).

+ * Any file names with indexes <= last_file_arg_seen are ignored;

+ * they have presumably been processed in a previous iteration.

+ * (Pass 0 for last_file_arg_seen on the first or only iteration.)

+ * for_real is FALSE on the first (dummy) pass; we may skip any expensive

+ * processing.

+ */

+{

+  int argn;

+  char * arg;

+  int quality;			/* -quality parameter */

+  int q_scale_factor;		/* scaling percentage for -qtables */

+  boolean force_baseline;

+  boolean simple_progressive;

+  char * qtablefile = NULL;	/* saves -qtables filename if any */

+  char * qslotsarg = NULL;	/* saves -qslots parm if any */

+  char * samplearg = NULL;	/* saves -sample parm if any */

+  char * scansarg = NULL;	/* saves -scans parm if any */

+

+  /* Set up default JPEG parameters. */

+  /* Note that default -quality level need not, and does not,

+   * match the default scaling for an explicit -qtables argument.

+   */

+  quality = 75;			/* default -quality value */

+  q_scale_factor = 100;		/* default to no scaling for -qtables */

+  force_baseline = FALSE;	/* by default, allow 16-bit quantizers */

+  simple_progressive = FALSE;

+  is_targa = FALSE;

+  outfilename = NULL;

+  cinfo->err->trace_level = 0;

+

+  /* Scan command line options, adjust parameters */

+

+  for (argn = 1; argn < argc; argn++) {

+    arg = argv[argn];

+    if (*arg != '-') {

+      /* Not a switch, must be a file name argument */

+      if (argn <= last_file_arg_seen) {

+	outfilename = NULL;	/* -outfile applies to just one input file */

+	continue;		/* ignore this name if previously processed */

+      }

+      break;			/* else done parsing switches */

+    }

+    arg++;			/* advance past switch marker character */

+

+    if (keymatch(arg, "arithmetic", 1)) {

+      /* Use arithmetic coding. */

+#ifdef C_ARITH_CODING_SUPPORTED

+      cinfo->arith_code = TRUE;

+#else

+      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "baseline", 1)) {

+      /* Force baseline-compatible output (8-bit quantizer values). */

+      force_baseline = TRUE;

+

+    } else if (keymatch(arg, "dct", 2)) {

+      /* Select DCT algorithm. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (keymatch(argv[argn], "int", 1)) {

+	cinfo->dct_method = JDCT_ISLOW;

+      } else if (keymatch(argv[argn], "fast", 2)) {

+	cinfo->dct_method = JDCT_IFAST;

+      } else if (keymatch(argv[argn], "float", 2)) {

+	cinfo->dct_method = JDCT_FLOAT;

+      } else

+	usage();

+

+    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {

+      /* Enable debug printouts. */

+      /* On first -d, print version identification */

+      static boolean printed_version = FALSE;

+

+      if (! printed_version) {

+	fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n",

+		JVERSION, JCOPYRIGHT);

+	printed_version = TRUE;

+      }

+      cinfo->err->trace_level++;

+

+    } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {

+      /* Force a monochrome JPEG file to be generated. */

+      jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);

+

+    } else if (keymatch(arg, "maxmemory", 3)) {

+      /* Maximum memory in Kb (or Mb with 'm'). */

+      long lval;

+      char ch = 'x';

+

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)

+	usage();

+      if (ch == 'm' || ch == 'M')

+	lval *= 1000L;

+      cinfo->mem->max_memory_to_use = lval * 1000L;

+

+    } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {

+      /* Enable entropy parm optimization. */

+#ifdef ENTROPY_OPT_SUPPORTED

+      cinfo->optimize_coding = TRUE;

+#else

+      fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "outfile", 4)) {

+      /* Set output file name. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      outfilename = argv[argn];	/* save it away for later use */

+

+    } else if (keymatch(arg, "progressive", 1)) {

+      /* Select simple progressive mode. */

+#ifdef C_PROGRESSIVE_SUPPORTED

+      simple_progressive = TRUE;

+      /* We must postpone execution until num_components is known. */

+#else

+      fprintf(stderr, "%s: sorry, progressive output was not compiled\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "quality", 1)) {

+      /* Quality factor (quantization table scaling factor). */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%d", &quality) != 1)

+	usage();

+      /* Change scale factor in case -qtables is present. */

+      q_scale_factor = jpeg_quality_scaling(quality);

+

+    } else if (keymatch(arg, "qslots", 2)) {

+      /* Quantization table slot numbers. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      qslotsarg = argv[argn];

+      /* Must delay setting qslots until after we have processed any

+       * colorspace-determining switches, since jpeg_set_colorspace sets

+       * default quant table numbers.

+       */

+

+    } else if (keymatch(arg, "qtables", 2)) {

+      /* Quantization tables fetched from file. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      qtablefile = argv[argn];

+      /* We postpone actually reading the file in case -quality comes later. */

+

+    } else if (keymatch(arg, "restart", 1)) {

+      /* Restart interval in MCU rows (or in MCUs with 'b'). */

+      long lval;

+      char ch = 'x';

+

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)

+	usage();

+      if (lval < 0 || lval > 65535L)

+	usage();

+      if (ch == 'b' || ch == 'B') {

+	cinfo->restart_interval = (unsigned int) lval;

+	cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */

+      } else {

+	cinfo->restart_in_rows = (int) lval;

+	/* restart_interval will be computed during startup */

+      }

+

+    } else if (keymatch(arg, "sample", 2)) {

+      /* Set sampling factors. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      samplearg = argv[argn];

+      /* Must delay setting sample factors until after we have processed any

+       * colorspace-determining switches, since jpeg_set_colorspace sets

+       * default sampling factors.

+       */

+

+    } else if (keymatch(arg, "scans", 2)) {

+      /* Set scan script. */

+#ifdef C_MULTISCAN_FILES_SUPPORTED

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      scansarg = argv[argn];

+      /* We must postpone reading the file in case -progressive appears. */

+#else

+      fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "smooth", 2)) {

+      /* Set input smoothing factor. */

+      int val;

+

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%d", &val) != 1)

+	usage();

+      if (val < 0 || val > 100)

+	usage();

+      cinfo->smoothing_factor = val;

+

+    } else if (keymatch(arg, "targa", 1)) {

+      /* Input file is Targa format. */

+      is_targa = TRUE;

+

+    } else {

+      usage();			/* bogus switch */

+    }

+  }

+

+  /* Post-switch-scanning cleanup */

+

+  if (for_real) {

+

+    /* Set quantization tables for selected quality. */

+    /* Some or all may be overridden if -qtables is present. */

+    jpeg_set_quality(cinfo, quality, force_baseline);

+

+    if (qtablefile != NULL)	/* process -qtables if it was present */

+      if (! read_quant_tables(cinfo, qtablefile,

+			      q_scale_factor, force_baseline))

+	usage();

+

+    if (qslotsarg != NULL)	/* process -qslots if it was present */

+      if (! set_quant_slots(cinfo, qslotsarg))

+	usage();

+

+    if (samplearg != NULL)	/* process -sample if it was present */

+      if (! set_sample_factors(cinfo, samplearg))

+	usage();

+

+#ifdef C_PROGRESSIVE_SUPPORTED

+    if (simple_progressive)	/* process -progressive; -scans can override */

+      jpeg_simple_progression(cinfo);

+#endif

+

+#ifdef C_MULTISCAN_FILES_SUPPORTED

+    if (scansarg != NULL)	/* process -scans if it was present */

+      if (! read_scan_script(cinfo, scansarg))

+	usage();

+#endif

+  }

+

+  return argn;			/* return index of next arg (file name) */

+}

+

+

+/*

+ * The main program.

+ */

+

+int

+main (int argc, char **argv)

+{

+  struct jpeg_compress_struct cinfo;

+  struct jpeg_error_mgr jerr;

+#ifdef PROGRESS_REPORT

+  struct cdjpeg_progress_mgr progress;

+#endif

+  int file_index;

+  cjpeg_source_ptr src_mgr;

+  FILE * input_file;

+  FILE * output_file;

+  JDIMENSION num_scanlines;

+

+  /* On Mac, fetch a command line. */

+#ifdef USE_CCOMMAND

+  argc = ccommand(&argv);

+#endif

+

+  progname = argv[0];

+  if (progname == NULL || progname[0] == 0)

+    progname = "cjpeg";		/* in case C library doesn't provide it */

+

+  /* Initialize the JPEG compression object with default error handling. */

+  cinfo.err = jpeg_std_error(&jerr);

+  jpeg_create_compress(&cinfo);

+  /* Add some application-specific error messages (from cderror.h) */

+  jerr.addon_message_table = cdjpeg_message_table;

+  jerr.first_addon_message = JMSG_FIRSTADDONCODE;

+  jerr.last_addon_message = JMSG_LASTADDONCODE;

+

+  /* Now safe to enable signal catcher. */

+#ifdef NEED_SIGNAL_CATCHER

+  enable_signal_catcher((j_common_ptr) &cinfo);

+#endif

+

+  /* Initialize JPEG parameters.

+   * Much of this may be overridden later.

+   * In particular, we don't yet know the input file's color space,

+   * but we need to provide some value for jpeg_set_defaults() to work.

+   */

+

+  cinfo.in_color_space = JCS_RGB; /* arbitrary guess */

+  jpeg_set_defaults(&cinfo);

+

+  /* Scan command line to find file names.

+   * It is convenient to use just one switch-parsing routine, but the switch

+   * values read here are ignored; we will rescan the switches after opening

+   * the input file.

+   */

+

+  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);

+

+#ifdef TWO_FILE_COMMANDLINE

+  /* Must have either -outfile switch or explicit output file name */

+  if (outfilename == NULL) {

+    if (file_index != argc-2) {

+      fprintf(stderr, "%s: must name one input and one output file\n",

+	      progname);

+      usage();

+    }

+    outfilename = argv[file_index+1];

+  } else {

+    if (file_index != argc-1) {

+      fprintf(stderr, "%s: must name one input and one output file\n",

+	      progname);

+      usage();

+    }

+  }

+#else

+  /* Unix style: expect zero or one file name */

+  if (file_index < argc-1) {

+    fprintf(stderr, "%s: only one input file\n", progname);

+    usage();

+  }

+#endif /* TWO_FILE_COMMANDLINE */

+

+  /* Open the input file. */

+  if (file_index < argc) {

+    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default input file is stdin */

+    input_file = read_stdin();

+  }

+

+  /* Open the output file. */

+  if (outfilename != NULL) {

+    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default output file is stdout */

+    output_file = write_stdout();

+  }

+

+#ifdef PROGRESS_REPORT

+  start_progress_monitor((j_common_ptr) &cinfo, &progress);

+#endif

+

+  /* Figure out the input file format, and set up to read it. */

+  src_mgr = select_file_type(&cinfo, input_file);

+  src_mgr->input_file = input_file;

+

+  /* Read the input file header to obtain file size & colorspace. */

+  (*src_mgr->start_input) (&cinfo, src_mgr);

+

+  /* Now that we know input colorspace, fix colorspace-dependent defaults */

+  jpeg_default_colorspace(&cinfo);

+

+  /* Adjust default compression parameters by re-parsing the options */

+  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);

+

+  /* Specify data destination for compression */

+  jpeg_stdio_dest(&cinfo, output_file);

+

+  /* Start compressor */

+  jpeg_start_compress(&cinfo, TRUE);

+

+  /* Process data */

+  while (cinfo.next_scanline < cinfo.image_height) {

+    num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);

+    (void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);

+  }

+

+  /* Finish compression and release memory */

+  (*src_mgr->finish_input) (&cinfo, src_mgr);

+  jpeg_finish_compress(&cinfo);

+  jpeg_destroy_compress(&cinfo);

+

+  /* Close files, if we opened them */

+  if (input_file != stdin)

+    fclose(input_file);

+  if (output_file != stdout)

+    fclose(output_file);

+

+#ifdef PROGRESS_REPORT

+  end_progress_monitor((j_common_ptr) &cinfo);

+#endif

+

+  /* All done. */

+  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);

+  return 0;			/* suppress no-return-value warnings */

+}

diff --git a/test/monniaux/jpeg-6b/djpeg.c b/test/monniaux/jpeg-6b/djpeg.c
index e099e90a..a63523c5 100644
--- a/test/monniaux/jpeg-6b/djpeg.c
+++ b/test/monniaux/jpeg-6b/djpeg.c
@@ -1,616 +1,616 @@
-/*
- * djpeg.c
- *
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains a command-line user interface for the JPEG decompressor.
- * It should work on any system with Unix- or MS-DOS-style command lines.
- *
- * Two different command line styles are permitted, depending on the
- * compile-time switch TWO_FILE_COMMANDLINE:
- *	djpeg [options]  inputfile outputfile
- *	djpeg [options]  [inputfile]
- * In the second style, output is always to standard output, which you'd
- * normally redirect to a file or pipe to some other program.  Input is
- * either from a named file or from standard input (typically redirected).
- * The second style is convenient on Unix but is unhelpful on systems that
- * don't support pipes.  Also, you MUST use the first style if your system
- * doesn't do binary I/O to stdin/stdout.
- * To simplify script writing, the "-outfile" switch is provided.  The syntax
- *	djpeg [options]  -outfile outputfile  inputfile
- * works regardless of which command line style is used.
- */
-
-#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */
-#include "jversion.h"		/* for version message */
-
-#include <ctype.h>		/* to declare isprint() */
-
-#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */
-#ifdef __MWERKS__
-#include <SIOUX.h>              /* Metrowerks needs this */
-#include <console.h>		/* ... and this */
-#endif
-#ifdef THINK_C
-#include <console.h>		/* Think declares it here */
-#endif
-#endif
-
-
-/* Create the add-on message string table. */
-
-#define JMESSAGE(code,string)	string ,
-
-static const char * const cdjpeg_message_table[] = {
-#include "cderror.h"
-  NULL
-};
-
-
-/*
- * This list defines the known output image formats
- * (not all of which need be supported by a given version).
- * You can change the default output format by defining DEFAULT_FMT;
- * indeed, you had better do so if you undefine PPM_SUPPORTED.
- */
-
-typedef enum {
-	FMT_BMP,		/* BMP format (Windows flavor) */
-	FMT_GIF,		/* GIF format */
-	FMT_OS2,		/* BMP format (OS/2 flavor) */
-	FMT_PPM,		/* PPM/PGM (PBMPLUS formats) */
-	FMT_RLE,		/* RLE format */
-	FMT_TARGA,		/* Targa format */
-	FMT_TIFF		/* TIFF format */
-} IMAGE_FORMATS;
-
-#ifndef DEFAULT_FMT		/* so can override from CFLAGS in Makefile */
-#define DEFAULT_FMT	FMT_PPM
-#endif
-
-static IMAGE_FORMATS requested_fmt;
-
-
-/*
- * Argument-parsing code.
- * The switch parser is designed to be useful with DOS-style command line
- * syntax, ie, intermixed switches and file names, where only the switches
- * to the left of a given file name affect processing of that file.
- * The main program in this file doesn't actually use this capability...
- */
-
-
-static const char * progname;	/* program name for error messages */
-static char * outfilename;	/* for -outfile switch */
-
-
-LOCAL(void)
-usage (void)
-/* complain about bad command line */
-{
-  fprintf(stderr, "usage: %s [switches] ", progname);
-#ifdef TWO_FILE_COMMANDLINE
-  fprintf(stderr, "inputfile outputfile\n");
-#else
-  fprintf(stderr, "[inputfile]\n");
-#endif
-
-  fprintf(stderr, "Switches (names may be abbreviated):\n");
-  fprintf(stderr, "  -colors N      Reduce image to no more than N colors\n");
-  fprintf(stderr, "  -fast          Fast, low-quality processing\n");
-  fprintf(stderr, "  -grayscale     Force grayscale output\n");
-#ifdef IDCT_SCALING_SUPPORTED
-  fprintf(stderr, "  -scale M/N     Scale output image by fraction M/N, eg, 1/8\n");
-#endif
-#ifdef BMP_SUPPORTED
-  fprintf(stderr, "  -bmp           Select BMP output format (Windows style)%s\n",
-	  (DEFAULT_FMT == FMT_BMP ? " (default)" : ""));
-#endif
-#ifdef GIF_SUPPORTED
-  fprintf(stderr, "  -gif           Select GIF output format%s\n",
-	  (DEFAULT_FMT == FMT_GIF ? " (default)" : ""));
-#endif
-#ifdef BMP_SUPPORTED
-  fprintf(stderr, "  -os2           Select BMP output format (OS/2 style)%s\n",
-	  (DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));
-#endif
-#ifdef PPM_SUPPORTED
-  fprintf(stderr, "  -pnm           Select PBMPLUS (PPM/PGM) output format%s\n",
-	  (DEFAULT_FMT == FMT_PPM ? " (default)" : ""));
-#endif
-#ifdef RLE_SUPPORTED
-  fprintf(stderr, "  -rle           Select Utah RLE output format%s\n",
-	  (DEFAULT_FMT == FMT_RLE ? " (default)" : ""));
-#endif
-#ifdef TARGA_SUPPORTED
-  fprintf(stderr, "  -targa         Select Targa output format%s\n",
-	  (DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));
-#endif
-  fprintf(stderr, "Switches for advanced users:\n");
-#ifdef DCT_ISLOW_SUPPORTED
-  fprintf(stderr, "  -dct int       Use integer DCT method%s\n",
-	  (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
-#endif
-#ifdef DCT_IFAST_SUPPORTED
-  fprintf(stderr, "  -dct fast      Use fast integer DCT (less accurate)%s\n",
-	  (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
-#endif
-#ifdef DCT_FLOAT_SUPPORTED
-  fprintf(stderr, "  -dct float     Use floating-point DCT method%s\n",
-	  (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
-#endif
-  fprintf(stderr, "  -dither fs     Use F-S dithering (default)\n");
-  fprintf(stderr, "  -dither none   Don't use dithering in quantization\n");
-  fprintf(stderr, "  -dither ordered  Use ordered dither (medium speed, quality)\n");
-#ifdef QUANT_2PASS_SUPPORTED
-  fprintf(stderr, "  -map FILE      Map to colors used in named image file\n");
-#endif
-  fprintf(stderr, "  -nosmooth      Don't use high-quality upsampling\n");
-#ifdef QUANT_1PASS_SUPPORTED
-  fprintf(stderr, "  -onepass       Use 1-pass quantization (fast, low quality)\n");
-#endif
-  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");
-  fprintf(stderr, "  -outfile name  Specify name for output file\n");
-  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");
-  exit(EXIT_FAILURE);
-}
-
-
-LOCAL(int)
-parse_switches (j_decompress_ptr cinfo, int argc, char **argv,
-		int last_file_arg_seen, boolean for_real)
-/* Parse optional switches.
- * Returns argv[] index of first file-name argument (== argc if none).
- * Any file names with indexes <= last_file_arg_seen are ignored;
- * they have presumably been processed in a previous iteration.
- * (Pass 0 for last_file_arg_seen on the first or only iteration.)
- * for_real is FALSE on the first (dummy) pass; we may skip any expensive
- * processing.
- */
-{
-  int argn;
-  char * arg;
-
-  /* Set up default JPEG parameters. */
-  requested_fmt = DEFAULT_FMT;	/* set default output file format */
-  outfilename = NULL;
-  cinfo->err->trace_level = 0;
-
-  /* Scan command line options, adjust parameters */
-
-  for (argn = 1; argn < argc; argn++) {
-    arg = argv[argn];
-    if (*arg != '-') {
-      /* Not a switch, must be a file name argument */
-      if (argn <= last_file_arg_seen) {
-	outfilename = NULL;	/* -outfile applies to just one input file */
-	continue;		/* ignore this name if previously processed */
-      }
-      break;			/* else done parsing switches */
-    }
-    arg++;			/* advance past switch marker character */
-
-    if (keymatch(arg, "bmp", 1)) {
-      /* BMP output format. */
-      requested_fmt = FMT_BMP;
-
-    } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||
-	       keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {
-      /* Do color quantization. */
-      int val;
-
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%d", &val) != 1)
-	usage();
-      cinfo->desired_number_of_colors = val;
-      cinfo->quantize_colors = TRUE;
-
-    } else if (keymatch(arg, "dct", 2)) {
-      /* Select IDCT algorithm. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (keymatch(argv[argn], "int", 1)) {
-	cinfo->dct_method = JDCT_ISLOW;
-      } else if (keymatch(argv[argn], "fast", 2)) {
-	cinfo->dct_method = JDCT_IFAST;
-      } else if (keymatch(argv[argn], "float", 2)) {
-	cinfo->dct_method = JDCT_FLOAT;
-      } else
-	usage();
-
-    } else if (keymatch(arg, "dither", 2)) {
-      /* Select dithering algorithm. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (keymatch(argv[argn], "fs", 2)) {
-	cinfo->dither_mode = JDITHER_FS;
-      } else if (keymatch(argv[argn], "none", 2)) {
-	cinfo->dither_mode = JDITHER_NONE;
-      } else if (keymatch(argv[argn], "ordered", 2)) {
-	cinfo->dither_mode = JDITHER_ORDERED;
-      } else
-	usage();
-
-    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
-      /* Enable debug printouts. */
-      /* On first -d, print version identification */
-      static boolean printed_version = FALSE;
-
-      if (! printed_version) {
-	fprintf(stderr, "Independent JPEG Group's DJPEG, version %s\n%s\n",
-		JVERSION, JCOPYRIGHT);
-	printed_version = TRUE;
-      }
-      cinfo->err->trace_level++;
-
-    } else if (keymatch(arg, "fast", 1)) {
-      /* Select recommended processing options for quick-and-dirty output. */
-      cinfo->two_pass_quantize = FALSE;
-      cinfo->dither_mode = JDITHER_ORDERED;
-      if (! cinfo->quantize_colors) /* don't override an earlier -colors */
-	cinfo->desired_number_of_colors = 216;
-      cinfo->dct_method = JDCT_FASTEST;
-      cinfo->do_fancy_upsampling = FALSE;
-
-    } else if (keymatch(arg, "gif", 1)) {
-      /* GIF output format. */
-      requested_fmt = FMT_GIF;
-
-    } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
-      /* Force monochrome output. */
-      cinfo->out_color_space = JCS_GRAYSCALE;
-
-    } else if (keymatch(arg, "map", 3)) {
-      /* Quantize to a color map taken from an input file. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (for_real) {		/* too expensive to do twice! */
-#ifdef QUANT_2PASS_SUPPORTED	/* otherwise can't quantize to supplied map */
-	FILE * mapfile;
-
-	if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {
-	  fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
-	  exit(EXIT_FAILURE);
-	}
-	read_color_map(cinfo, mapfile);
-	fclose(mapfile);
-	cinfo->quantize_colors = TRUE;
-#else
-	ERREXIT(cinfo, JERR_NOT_COMPILED);
-#endif
-      }
-
-    } else if (keymatch(arg, "maxmemory", 3)) {
-      /* Maximum memory in Kb (or Mb with 'm'). */
-      long lval;
-      char ch = 'x';
-
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
-	usage();
-      if (ch == 'm' || ch == 'M')
-	lval *= 1000L;
-      cinfo->mem->max_memory_to_use = lval * 1000L;
-
-    } else if (keymatch(arg, "nosmooth", 3)) {
-      /* Suppress fancy upsampling */
-      cinfo->do_fancy_upsampling = FALSE;
-
-    } else if (keymatch(arg, "onepass", 3)) {
-      /* Use fast one-pass quantization. */
-      cinfo->two_pass_quantize = FALSE;
-
-    } else if (keymatch(arg, "os2", 3)) {
-      /* BMP output format (OS/2 flavor). */
-      requested_fmt = FMT_OS2;
-
-    } else if (keymatch(arg, "outfile", 4)) {
-      /* Set output file name. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      outfilename = argv[argn];	/* save it away for later use */
-
-    } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {
-      /* PPM/PGM output format. */
-      requested_fmt = FMT_PPM;
-
-    } else if (keymatch(arg, "rle", 1)) {
-      /* RLE output format. */
-      requested_fmt = FMT_RLE;
-
-    } else if (keymatch(arg, "scale", 1)) {
-      /* Scale the output image by a fraction M/N. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%d/%d",
-		 &cinfo->scale_num, &cinfo->scale_denom) != 2)
-	usage();
-
-    } else if (keymatch(arg, "targa", 1)) {
-      /* Targa output format. */
-      requested_fmt = FMT_TARGA;
-
-    } else {
-      usage();			/* bogus switch */
-    }
-  }
-
-  return argn;			/* return index of next arg (file name) */
-}
-
-
-/*
- * Marker processor for COM and interesting APPn markers.
- * This replaces the library's built-in processor, which just skips the marker.
- * We want to print out the marker as text, to the extent possible.
- * Note this code relies on a non-suspending data source.
- */
-
-LOCAL(unsigned int)
-jpeg_getc (j_decompress_ptr cinfo)
-/* Read next byte */
-{
-  struct jpeg_source_mgr * datasrc = cinfo->src;
-
-  if (datasrc->bytes_in_buffer == 0) {
-    if (! (*datasrc->fill_input_buffer) (cinfo))
-      ERREXIT(cinfo, JERR_CANT_SUSPEND);
-  }
-  datasrc->bytes_in_buffer--;
-  return GETJOCTET(*datasrc->next_input_byte++);
-}
-
-
-METHODDEF(boolean)
-print_text_marker (j_decompress_ptr cinfo)
-{
-  boolean traceit = (cinfo->err->trace_level >= 1);
-  INT32 length;
-  unsigned int ch;
-  unsigned int lastch = 0;
-
-  length = jpeg_getc(cinfo) << 8;
-  length += jpeg_getc(cinfo);
-  length -= 2;			/* discount the length word itself */
-
-  if (traceit) {
-    if (cinfo->unread_marker == JPEG_COM)
-      fprintf(stderr, "Comment, length %ld:\n", (long) length);
-    else			/* assume it is an APPn otherwise */
-      fprintf(stderr, "APP%d, length %ld:\n",
-	      cinfo->unread_marker - JPEG_APP0, (long) length);
-  }
-
-  while (--length >= 0) {
-    ch = jpeg_getc(cinfo);
-    if (traceit) {
-      /* Emit the character in a readable form.
-       * Nonprintables are converted to \nnn form,
-       * while \ is converted to \\.
-       * Newlines in CR, CR/LF, or LF form will be printed as one newline.
-       */
-      if (ch == '\r') {
-	fprintf(stderr, "\n");
-      } else if (ch == '\n') {
-	if (lastch != '\r')
-	  fprintf(stderr, "\n");
-      } else if (ch == '\\') {
-	fprintf(stderr, "\\\\");
-      } else if (isprint(ch)) {
-	putc(ch, stderr);
-      } else {
-	fprintf(stderr, "\\%03o", ch);
-      }
-      lastch = ch;
-    }
-  }
-
-  if (traceit)
-    fprintf(stderr, "\n");
-
-  return TRUE;
-}
-
-
-/*
- * The main program.
- */
-
-int
-main (int argc, char **argv)
-{
-  struct jpeg_decompress_struct cinfo;
-  struct jpeg_error_mgr jerr;
-#ifdef PROGRESS_REPORT
-  struct cdjpeg_progress_mgr progress;
-#endif
-  int file_index;
-  djpeg_dest_ptr dest_mgr = NULL;
-  FILE * input_file;
-  FILE * output_file;
-  JDIMENSION num_scanlines;
-
-  /* On Mac, fetch a command line. */
-#ifdef USE_CCOMMAND
-  argc = ccommand(&argv);
-#endif
-
-  progname = argv[0];
-  if (progname == NULL || progname[0] == 0)
-    progname = "djpeg";		/* in case C library doesn't provide it */
-
-  /* Initialize the JPEG decompression object with default error handling. */
-  cinfo.err = jpeg_std_error(&jerr);
-  jpeg_create_decompress(&cinfo);
-  /* Add some application-specific error messages (from cderror.h) */
-  jerr.addon_message_table = cdjpeg_message_table;
-  jerr.first_addon_message = JMSG_FIRSTADDONCODE;
-  jerr.last_addon_message = JMSG_LASTADDONCODE;
-
-  /* Insert custom marker processor for COM and APP12.
-   * APP12 is used by some digital camera makers for textual info,
-   * so we provide the ability to display it as text.
-   * If you like, additional APPn marker types can be selected for display,
-   * but don't try to override APP0 or APP14 this way (see libjpeg.doc).
-   */
-  jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
-  jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker);
-
-  /* Now safe to enable signal catcher. */
-#ifdef NEED_SIGNAL_CATCHER
-  enable_signal_catcher((j_common_ptr) &cinfo);
-#endif
-
-  /* Scan command line to find file names. */
-  /* It is convenient to use just one switch-parsing routine, but the switch
-   * values read here are ignored; we will rescan the switches after opening
-   * the input file.
-   * (Exception: tracing level set here controls verbosity for COM markers
-   * found during jpeg_read_header...)
-   */
-
-  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
-
-#ifdef TWO_FILE_COMMANDLINE
-  /* Must have either -outfile switch or explicit output file name */
-  if (outfilename == NULL) {
-    if (file_index != argc-2) {
-      fprintf(stderr, "%s: must name one input and one output file\n",
-	      progname);
-      usage();
-    }
-    outfilename = argv[file_index+1];
-  } else {
-    if (file_index != argc-1) {
-      fprintf(stderr, "%s: must name one input and one output file\n",
-	      progname);
-      usage();
-    }
-  }
-#else
-  /* Unix style: expect zero or one file name */
-  if (file_index < argc-1) {
-    fprintf(stderr, "%s: only one input file\n", progname);
-    usage();
-  }
-#endif /* TWO_FILE_COMMANDLINE */
-
-  /* Open the input file. */
-  if (file_index < argc) {
-    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default input file is stdin */
-    input_file = read_stdin();
-  }
-
-  /* Open the output file. */
-  if (outfilename != NULL) {
-    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default output file is stdout */
-    output_file = write_stdout();
-  }
-
-#ifdef PROGRESS_REPORT
-  start_progress_monitor((j_common_ptr) &cinfo, &progress);
-#endif
-
-  /* Specify data source for decompression */
-  jpeg_stdio_src(&cinfo, input_file);
-
-  /* Read file header, set default decompression parameters */
-  (void) jpeg_read_header(&cinfo, TRUE);
-
-  /* Adjust default decompression parameters by re-parsing the options */
-  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
-
-  /* Initialize the output module now to let it override any crucial
-   * option settings (for instance, GIF wants to force color quantization).
-   */
-  switch (requested_fmt) {
-#ifdef BMP_SUPPORTED
-  case FMT_BMP:
-    dest_mgr = jinit_write_bmp(&cinfo, FALSE);
-    break;
-  case FMT_OS2:
-    dest_mgr = jinit_write_bmp(&cinfo, TRUE);
-    break;
-#endif
-#ifdef GIF_SUPPORTED
-  case FMT_GIF:
-    dest_mgr = jinit_write_gif(&cinfo);
-    break;
-#endif
-#ifdef PPM_SUPPORTED
-  case FMT_PPM:
-    dest_mgr = jinit_write_ppm(&cinfo);
-    break;
-#endif
-#ifdef RLE_SUPPORTED
-  case FMT_RLE:
-    dest_mgr = jinit_write_rle(&cinfo);
-    break;
-#endif
-#ifdef TARGA_SUPPORTED
-  case FMT_TARGA:
-    dest_mgr = jinit_write_targa(&cinfo);
-    break;
-#endif
-  default:
-    ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
-    break;
-  }
-  dest_mgr->output_file = output_file;
-
-  /* Start decompressor */
-  (void) jpeg_start_decompress(&cinfo);
-
-  /* Write output file header */
-  (*dest_mgr->start_output) (&cinfo, dest_mgr);
-
-  /* Process data */
-  while (cinfo.output_scanline < cinfo.output_height) {
-    num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
-					dest_mgr->buffer_height);
-    (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
-  }
-
-#ifdef PROGRESS_REPORT
-  /* Hack: count final pass as done in case finish_output does an extra pass.
-   * The library won't have updated completed_passes.
-   */
-  progress.pub.completed_passes = progress.pub.total_passes;
-#endif
-
-  /* Finish decompression and release memory.
-   * I must do it in this order because output module has allocated memory
-   * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
-   */
-  (*dest_mgr->finish_output) (&cinfo, dest_mgr);
-  (void) jpeg_finish_decompress(&cinfo);
-  jpeg_destroy_decompress(&cinfo);
-
-  /* Close files, if we opened them */
-  if (input_file != stdin)
-    fclose(input_file);
-  if (output_file != stdout)
-    fclose(output_file);
-
-#ifdef PROGRESS_REPORT
-  end_progress_monitor((j_common_ptr) &cinfo);
-#endif
-
-  /* All done. */
-  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
-  return 0;			/* suppress no-return-value warnings */
-}
+/*

+ * djpeg.c

+ *

+ * Copyright (C) 1991-1997, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains a command-line user interface for the JPEG decompressor.

+ * It should work on any system with Unix- or MS-DOS-style command lines.

+ *

+ * Two different command line styles are permitted, depending on the

+ * compile-time switch TWO_FILE_COMMANDLINE:

+ *	djpeg [options]  inputfile outputfile

+ *	djpeg [options]  [inputfile]

+ * In the second style, output is always to standard output, which you'd

+ * normally redirect to a file or pipe to some other program.  Input is

+ * either from a named file or from standard input (typically redirected).

+ * The second style is convenient on Unix but is unhelpful on systems that

+ * don't support pipes.  Also, you MUST use the first style if your system

+ * doesn't do binary I/O to stdin/stdout.

+ * To simplify script writing, the "-outfile" switch is provided.  The syntax

+ *	djpeg [options]  -outfile outputfile  inputfile

+ * works regardless of which command line style is used.

+ */

+

+#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */

+#include "jversion.h"		/* for version message */

+

+#include <ctype.h>		/* to declare isprint() */

+

+#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */

+#ifdef __MWERKS__

+#include <SIOUX.h>              /* Metrowerks needs this */

+#include <console.h>		/* ... and this */

+#endif

+#ifdef THINK_C

+#include <console.h>		/* Think declares it here */

+#endif

+#endif

+

+

+/* Create the add-on message string table. */

+

+#define JMESSAGE(code,string)	string ,

+

+static const char * const cdjpeg_message_table[] = {

+#include "cderror.h"

+  NULL

+};

+

+

+/*

+ * This list defines the known output image formats

+ * (not all of which need be supported by a given version).

+ * You can change the default output format by defining DEFAULT_FMT;

+ * indeed, you had better do so if you undefine PPM_SUPPORTED.

+ */

+

+typedef enum {

+	FMT_BMP,		/* BMP format (Windows flavor) */

+	FMT_GIF,		/* GIF format */

+	FMT_OS2,		/* BMP format (OS/2 flavor) */

+	FMT_PPM,		/* PPM/PGM (PBMPLUS formats) */

+	FMT_RLE,		/* RLE format */

+	FMT_TARGA,		/* Targa format */

+	FMT_TIFF		/* TIFF format */

+} IMAGE_FORMATS;

+

+#ifndef DEFAULT_FMT		/* so can override from CFLAGS in Makefile */

+#define DEFAULT_FMT	FMT_PPM

+#endif

+

+static IMAGE_FORMATS requested_fmt;

+

+

+/*

+ * Argument-parsing code.

+ * The switch parser is designed to be useful with DOS-style command line

+ * syntax, ie, intermixed switches and file names, where only the switches

+ * to the left of a given file name affect processing of that file.

+ * The main program in this file doesn't actually use this capability...

+ */

+

+

+static const char * progname;	/* program name for error messages */

+static char * outfilename;	/* for -outfile switch */

+

+

+LOCAL(void)

+usage (void)

+/* complain about bad command line */

+{

+  fprintf(stderr, "usage: %s [switches] ", progname);

+#ifdef TWO_FILE_COMMANDLINE

+  fprintf(stderr, "inputfile outputfile\n");

+#else

+  fprintf(stderr, "[inputfile]\n");

+#endif

+

+  fprintf(stderr, "Switches (names may be abbreviated):\n");

+  fprintf(stderr, "  -colors N      Reduce image to no more than N colors\n");

+  fprintf(stderr, "  -fast          Fast, low-quality processing\n");

+  fprintf(stderr, "  -grayscale     Force grayscale output\n");

+#ifdef IDCT_SCALING_SUPPORTED

+  fprintf(stderr, "  -scale M/N     Scale output image by fraction M/N, eg, 1/8\n");

+#endif

+#ifdef BMP_SUPPORTED

+  fprintf(stderr, "  -bmp           Select BMP output format (Windows style)%s\n",

+	  (DEFAULT_FMT == FMT_BMP ? " (default)" : ""));

+#endif

+#ifdef GIF_SUPPORTED

+  fprintf(stderr, "  -gif           Select GIF output format%s\n",

+	  (DEFAULT_FMT == FMT_GIF ? " (default)" : ""));

+#endif

+#ifdef BMP_SUPPORTED

+  fprintf(stderr, "  -os2           Select BMP output format (OS/2 style)%s\n",

+	  (DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));

+#endif

+#ifdef PPM_SUPPORTED

+  fprintf(stderr, "  -pnm           Select PBMPLUS (PPM/PGM) output format%s\n",

+	  (DEFAULT_FMT == FMT_PPM ? " (default)" : ""));

+#endif

+#ifdef RLE_SUPPORTED

+  fprintf(stderr, "  -rle           Select Utah RLE output format%s\n",

+	  (DEFAULT_FMT == FMT_RLE ? " (default)" : ""));

+#endif

+#ifdef TARGA_SUPPORTED

+  fprintf(stderr, "  -targa         Select Targa output format%s\n",

+	  (DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));

+#endif

+  fprintf(stderr, "Switches for advanced users:\n");

+#ifdef DCT_ISLOW_SUPPORTED

+  fprintf(stderr, "  -dct int       Use integer DCT method%s\n",

+	  (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));

+#endif

+#ifdef DCT_IFAST_SUPPORTED

+  fprintf(stderr, "  -dct fast      Use fast integer DCT (less accurate)%s\n",

+	  (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));

+#endif

+#ifdef DCT_FLOAT_SUPPORTED

+  fprintf(stderr, "  -dct float     Use floating-point DCT method%s\n",

+	  (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));

+#endif

+  fprintf(stderr, "  -dither fs     Use F-S dithering (default)\n");

+  fprintf(stderr, "  -dither none   Don't use dithering in quantization\n");

+  fprintf(stderr, "  -dither ordered  Use ordered dither (medium speed, quality)\n");

+#ifdef QUANT_2PASS_SUPPORTED

+  fprintf(stderr, "  -map FILE      Map to colors used in named image file\n");

+#endif

+  fprintf(stderr, "  -nosmooth      Don't use high-quality upsampling\n");

+#ifdef QUANT_1PASS_SUPPORTED

+  fprintf(stderr, "  -onepass       Use 1-pass quantization (fast, low quality)\n");

+#endif

+  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");

+  fprintf(stderr, "  -outfile name  Specify name for output file\n");

+  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");

+  exit(EXIT_FAILURE);

+}

+

+

+LOCAL(int)

+parse_switches (j_decompress_ptr cinfo, int argc, char **argv,

+		int last_file_arg_seen, boolean for_real)

+/* Parse optional switches.

+ * Returns argv[] index of first file-name argument (== argc if none).

+ * Any file names with indexes <= last_file_arg_seen are ignored;

+ * they have presumably been processed in a previous iteration.

+ * (Pass 0 for last_file_arg_seen on the first or only iteration.)

+ * for_real is FALSE on the first (dummy) pass; we may skip any expensive

+ * processing.

+ */

+{

+  int argn;

+  char * arg;

+

+  /* Set up default JPEG parameters. */

+  requested_fmt = DEFAULT_FMT;	/* set default output file format */

+  outfilename = NULL;

+  cinfo->err->trace_level = 0;

+

+  /* Scan command line options, adjust parameters */

+

+  for (argn = 1; argn < argc; argn++) {

+    arg = argv[argn];

+    if (*arg != '-') {

+      /* Not a switch, must be a file name argument */

+      if (argn <= last_file_arg_seen) {

+	outfilename = NULL;	/* -outfile applies to just one input file */

+	continue;		/* ignore this name if previously processed */

+      }

+      break;			/* else done parsing switches */

+    }

+    arg++;			/* advance past switch marker character */

+

+    if (keymatch(arg, "bmp", 1)) {

+      /* BMP output format. */

+      requested_fmt = FMT_BMP;

+

+    } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||

+	       keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {

+      /* Do color quantization. */

+      int val;

+

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%d", &val) != 1)

+	usage();

+      cinfo->desired_number_of_colors = val;

+      cinfo->quantize_colors = TRUE;

+

+    } else if (keymatch(arg, "dct", 2)) {

+      /* Select IDCT algorithm. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (keymatch(argv[argn], "int", 1)) {

+	cinfo->dct_method = JDCT_ISLOW;

+      } else if (keymatch(argv[argn], "fast", 2)) {

+	cinfo->dct_method = JDCT_IFAST;

+      } else if (keymatch(argv[argn], "float", 2)) {

+	cinfo->dct_method = JDCT_FLOAT;

+      } else

+	usage();

+

+    } else if (keymatch(arg, "dither", 2)) {

+      /* Select dithering algorithm. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (keymatch(argv[argn], "fs", 2)) {

+	cinfo->dither_mode = JDITHER_FS;

+      } else if (keymatch(argv[argn], "none", 2)) {

+	cinfo->dither_mode = JDITHER_NONE;

+      } else if (keymatch(argv[argn], "ordered", 2)) {

+	cinfo->dither_mode = JDITHER_ORDERED;

+      } else

+	usage();

+

+    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {

+      /* Enable debug printouts. */

+      /* On first -d, print version identification */

+      static boolean printed_version = FALSE;

+

+      if (! printed_version) {

+	fprintf(stderr, "Independent JPEG Group's DJPEG, version %s\n%s\n",

+		JVERSION, JCOPYRIGHT);

+	printed_version = TRUE;

+      }

+      cinfo->err->trace_level++;

+

+    } else if (keymatch(arg, "fast", 1)) {

+      /* Select recommended processing options for quick-and-dirty output. */

+      cinfo->two_pass_quantize = FALSE;

+      cinfo->dither_mode = JDITHER_ORDERED;

+      if (! cinfo->quantize_colors) /* don't override an earlier -colors */

+	cinfo->desired_number_of_colors = 216;

+      cinfo->dct_method = JDCT_FASTEST;

+      cinfo->do_fancy_upsampling = FALSE;

+

+    } else if (keymatch(arg, "gif", 1)) {

+      /* GIF output format. */

+      requested_fmt = FMT_GIF;

+

+    } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {

+      /* Force monochrome output. */

+      cinfo->out_color_space = JCS_GRAYSCALE;

+

+    } else if (keymatch(arg, "map", 3)) {

+      /* Quantize to a color map taken from an input file. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (for_real) {		/* too expensive to do twice! */

+#ifdef QUANT_2PASS_SUPPORTED	/* otherwise can't quantize to supplied map */

+	FILE * mapfile;

+

+	if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {

+	  fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);

+	  exit(EXIT_FAILURE);

+	}

+	read_color_map(cinfo, mapfile);

+	fclose(mapfile);

+	cinfo->quantize_colors = TRUE;

+#else

+	ERREXIT(cinfo, JERR_NOT_COMPILED);

+#endif

+      }

+

+    } else if (keymatch(arg, "maxmemory", 3)) {

+      /* Maximum memory in Kb (or Mb with 'm'). */

+      long lval;

+      char ch = 'x';

+

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)

+	usage();

+      if (ch == 'm' || ch == 'M')

+	lval *= 1000L;

+      cinfo->mem->max_memory_to_use = lval * 1000L;

+

+    } else if (keymatch(arg, "nosmooth", 3)) {

+      /* Suppress fancy upsampling */

+      cinfo->do_fancy_upsampling = FALSE;

+

+    } else if (keymatch(arg, "onepass", 3)) {

+      /* Use fast one-pass quantization. */

+      cinfo->two_pass_quantize = FALSE;

+

+    } else if (keymatch(arg, "os2", 3)) {

+      /* BMP output format (OS/2 flavor). */

+      requested_fmt = FMT_OS2;

+

+    } else if (keymatch(arg, "outfile", 4)) {

+      /* Set output file name. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      outfilename = argv[argn];	/* save it away for later use */

+

+    } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {

+      /* PPM/PGM output format. */

+      requested_fmt = FMT_PPM;

+

+    } else if (keymatch(arg, "rle", 1)) {

+      /* RLE output format. */

+      requested_fmt = FMT_RLE;

+

+    } else if (keymatch(arg, "scale", 1)) {

+      /* Scale the output image by a fraction M/N. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%d/%d",

+		 &cinfo->scale_num, &cinfo->scale_denom) != 2)

+	usage();

+

+    } else if (keymatch(arg, "targa", 1)) {

+      /* Targa output format. */

+      requested_fmt = FMT_TARGA;

+

+    } else {

+      usage();			/* bogus switch */

+    }

+  }

+

+  return argn;			/* return index of next arg (file name) */

+}

+

+

+/*

+ * Marker processor for COM and interesting APPn markers.

+ * This replaces the library's built-in processor, which just skips the marker.

+ * We want to print out the marker as text, to the extent possible.

+ * Note this code relies on a non-suspending data source.

+ */

+

+LOCAL(unsigned int)

+jpeg_getc (j_decompress_ptr cinfo)

+/* Read next byte */

+{

+  struct jpeg_source_mgr * datasrc = cinfo->src;

+

+  if (datasrc->bytes_in_buffer == 0) {

+    if (! (*datasrc->fill_input_buffer) (cinfo))

+      ERREXIT(cinfo, JERR_CANT_SUSPEND);

+  }

+  datasrc->bytes_in_buffer--;

+  return GETJOCTET(*datasrc->next_input_byte++);

+}

+

+

+METHODDEF(boolean)

+print_text_marker (j_decompress_ptr cinfo)

+{

+  boolean traceit = (cinfo->err->trace_level >= 1);

+  INT32 length;

+  unsigned int ch;

+  unsigned int lastch = 0;

+

+  length = jpeg_getc(cinfo) << 8;

+  length += jpeg_getc(cinfo);

+  length -= 2;			/* discount the length word itself */

+

+  if (traceit) {

+    if (cinfo->unread_marker == JPEG_COM)

+      fprintf(stderr, "Comment, length %ld:\n", (long) length);

+    else			/* assume it is an APPn otherwise */

+      fprintf(stderr, "APP%d, length %ld:\n",

+	      cinfo->unread_marker - JPEG_APP0, (long) length);

+  }

+

+  while (--length >= 0) {

+    ch = jpeg_getc(cinfo);

+    if (traceit) {

+      /* Emit the character in a readable form.

+       * Nonprintables are converted to \nnn form,

+       * while \ is converted to \\.

+       * Newlines in CR, CR/LF, or LF form will be printed as one newline.

+       */

+      if (ch == '\r') {

+	fprintf(stderr, "\n");

+      } else if (ch == '\n') {

+	if (lastch != '\r')

+	  fprintf(stderr, "\n");

+      } else if (ch == '\\') {

+	fprintf(stderr, "\\\\");

+      } else if (isprint(ch)) {

+	putc(ch, stderr);

+      } else {

+	fprintf(stderr, "\\%03o", ch);

+      }

+      lastch = ch;

+    }

+  }

+

+  if (traceit)

+    fprintf(stderr, "\n");

+

+  return TRUE;

+}

+

+

+/*

+ * The main program.

+ */

+

+int

+main (int argc, char **argv)

+{

+  struct jpeg_decompress_struct cinfo;

+  struct jpeg_error_mgr jerr;

+#ifdef PROGRESS_REPORT

+  struct cdjpeg_progress_mgr progress;

+#endif

+  int file_index;

+  djpeg_dest_ptr dest_mgr = NULL;

+  FILE * input_file;

+  FILE * output_file;

+  JDIMENSION num_scanlines;

+

+  /* On Mac, fetch a command line. */

+#ifdef USE_CCOMMAND

+  argc = ccommand(&argv);

+#endif

+

+  progname = argv[0];

+  if (progname == NULL || progname[0] == 0)

+    progname = "djpeg";		/* in case C library doesn't provide it */

+

+  /* Initialize the JPEG decompression object with default error handling. */

+  cinfo.err = jpeg_std_error(&jerr);

+  jpeg_create_decompress(&cinfo);

+  /* Add some application-specific error messages (from cderror.h) */

+  jerr.addon_message_table = cdjpeg_message_table;

+  jerr.first_addon_message = JMSG_FIRSTADDONCODE;

+  jerr.last_addon_message = JMSG_LASTADDONCODE;

+

+  /* Insert custom marker processor for COM and APP12.

+   * APP12 is used by some digital camera makers for textual info,

+   * so we provide the ability to display it as text.

+   * If you like, additional APPn marker types can be selected for display,

+   * but don't try to override APP0 or APP14 this way (see libjpeg.doc).

+   */

+  jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);

+  jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker);

+

+  /* Now safe to enable signal catcher. */

+#ifdef NEED_SIGNAL_CATCHER

+  enable_signal_catcher((j_common_ptr) &cinfo);

+#endif

+

+  /* Scan command line to find file names. */

+  /* It is convenient to use just one switch-parsing routine, but the switch

+   * values read here are ignored; we will rescan the switches after opening

+   * the input file.

+   * (Exception: tracing level set here controls verbosity for COM markers

+   * found during jpeg_read_header...)

+   */

+

+  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);

+

+#ifdef TWO_FILE_COMMANDLINE

+  /* Must have either -outfile switch or explicit output file name */

+  if (outfilename == NULL) {

+    if (file_index != argc-2) {

+      fprintf(stderr, "%s: must name one input and one output file\n",

+	      progname);

+      usage();

+    }

+    outfilename = argv[file_index+1];

+  } else {

+    if (file_index != argc-1) {

+      fprintf(stderr, "%s: must name one input and one output file\n",

+	      progname);

+      usage();

+    }

+  }

+#else

+  /* Unix style: expect zero or one file name */

+  if (file_index < argc-1) {

+    fprintf(stderr, "%s: only one input file\n", progname);

+    usage();

+  }

+#endif /* TWO_FILE_COMMANDLINE */

+

+  /* Open the input file. */

+  if (file_index < argc) {

+    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default input file is stdin */

+    input_file = read_stdin();

+  }

+

+  /* Open the output file. */

+  if (outfilename != NULL) {

+    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default output file is stdout */

+    output_file = write_stdout();

+  }

+

+#ifdef PROGRESS_REPORT

+  start_progress_monitor((j_common_ptr) &cinfo, &progress);

+#endif

+

+  /* Specify data source for decompression */

+  jpeg_stdio_src(&cinfo, input_file);

+

+  /* Read file header, set default decompression parameters */

+  (void) jpeg_read_header(&cinfo, TRUE);

+

+  /* Adjust default decompression parameters by re-parsing the options */

+  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);

+

+  /* Initialize the output module now to let it override any crucial

+   * option settings (for instance, GIF wants to force color quantization).

+   */

+  switch (requested_fmt) {

+#ifdef BMP_SUPPORTED

+  case FMT_BMP:

+    dest_mgr = jinit_write_bmp(&cinfo, FALSE);

+    break;

+  case FMT_OS2:

+    dest_mgr = jinit_write_bmp(&cinfo, TRUE);

+    break;

+#endif

+#ifdef GIF_SUPPORTED

+  case FMT_GIF:

+    dest_mgr = jinit_write_gif(&cinfo);

+    break;

+#endif

+#ifdef PPM_SUPPORTED

+  case FMT_PPM:

+    dest_mgr = jinit_write_ppm(&cinfo);

+    break;

+#endif

+#ifdef RLE_SUPPORTED

+  case FMT_RLE:

+    dest_mgr = jinit_write_rle(&cinfo);

+    break;

+#endif

+#ifdef TARGA_SUPPORTED

+  case FMT_TARGA:

+    dest_mgr = jinit_write_targa(&cinfo);

+    break;

+#endif

+  default:

+    ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);

+    break;

+  }

+  dest_mgr->output_file = output_file;

+

+  /* Start decompressor */

+  (void) jpeg_start_decompress(&cinfo);

+

+  /* Write output file header */

+  (*dest_mgr->start_output) (&cinfo, dest_mgr);

+

+  /* Process data */

+  while (cinfo.output_scanline < cinfo.output_height) {

+    num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,

+					dest_mgr->buffer_height);

+    (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);

+  }

+

+#ifdef PROGRESS_REPORT

+  /* Hack: count final pass as done in case finish_output does an extra pass.

+   * The library won't have updated completed_passes.

+   */

+  progress.pub.completed_passes = progress.pub.total_passes;

+#endif

+

+  /* Finish decompression and release memory.

+   * I must do it in this order because output module has allocated memory

+   * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.

+   */

+  (*dest_mgr->finish_output) (&cinfo, dest_mgr);

+  (void) jpeg_finish_decompress(&cinfo);

+  jpeg_destroy_decompress(&cinfo);

+

+  /* Close files, if we opened them */

+  if (input_file != stdin)

+    fclose(input_file);

+  if (output_file != stdout)

+    fclose(output_file);

+

+#ifdef PROGRESS_REPORT

+  end_progress_monitor((j_common_ptr) &cinfo);

+#endif

+

+  /* All done. */

+  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);

+  return 0;			/* suppress no-return-value warnings */

+}

diff --git a/test/monniaux/jpeg-6b/example.c b/test/monniaux/jpeg-6b/example.c
index 7fc354f0..9dcbd7d9 100644
--- a/test/monniaux/jpeg-6b/example.c
+++ b/test/monniaux/jpeg-6b/example.c
@@ -1,433 +1,433 @@
-/*
- * example.c
- *
- * This file illustrates how to use the IJG code as a subroutine library
- * to read or write JPEG image files.  You should look at this code in
- * conjunction with the documentation file libjpeg.doc.
- *
- * This code will not do anything useful as-is, but it may be helpful as a
- * skeleton for constructing routines that call the JPEG library.  
- *
- * We present these routines in the same coding style used in the JPEG code
- * (ANSI function definitions, etc); but you are of course free to code your
- * routines in a different style if you prefer.
- */
-
-#include <stdio.h>
-
-/*
- * Include file for users of JPEG library.
- * You will need to have included system headers that define at least
- * the typedefs FILE and size_t before you can include jpeglib.h.
- * (stdio.h is sufficient on ANSI-conforming systems.)
- * You may also wish to include "jerror.h".
- */
-
-#include "jpeglib.h"
-
-/*
- * <setjmp.h> is used for the optional error recovery mechanism shown in
- * the second part of the example.
- */
-
-#include <setjmp.h>
-
-
-
-/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/
-
-/* This half of the example shows how to feed data into the JPEG compressor.
- * We present a minimal version that does not worry about refinements such
- * as error recovery (the JPEG code will just exit() if it gets an error).
- */
-
-
-/*
- * IMAGE DATA FORMATS:
- *
- * The standard input image format is a rectangular array of pixels, with
- * each pixel having the same number of "component" values (color channels).
- * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars).
- * If you are working with color data, then the color values for each pixel
- * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit
- * RGB color.
- *
- * For this example, we'll assume that this data structure matches the way
- * our application has stored the image in memory, so we can just pass a
- * pointer to our image buffer.  In particular, let's say that the image is
- * RGB color and is described by:
- */
-
-extern JSAMPLE * image_buffer;	/* Points to large array of R,G,B-order data */
-extern int image_height;	/* Number of rows in image */
-extern int image_width;		/* Number of columns in image */
-
-
-/*
- * Sample routine for JPEG compression.  We assume that the target file name
- * and a compression quality factor are passed in.
- */
-
-GLOBAL(void)
-write_JPEG_file (char * filename, int quality)
-{
-  /* This struct contains the JPEG compression parameters and pointers to
-   * working space (which is allocated as needed by the JPEG library).
-   * It is possible to have several such structures, representing multiple
-   * compression/decompression processes, in existence at once.  We refer
-   * to any one struct (and its associated working data) as a "JPEG object".
-   */
-  struct jpeg_compress_struct cinfo;
-  /* This struct represents a JPEG error handler.  It is declared separately
-   * because applications often want to supply a specialized error handler
-   * (see the second half of this file for an example).  But here we just
-   * take the easy way out and use the standard error handler, which will
-   * print a message on stderr and call exit() if compression fails.
-   * Note that this struct must live as long as the main JPEG parameter
-   * struct, to avoid dangling-pointer problems.
-   */
-  struct jpeg_error_mgr jerr;
-  /* More stuff */
-  FILE * outfile;		/* target file */
-  JSAMPROW row_pointer[1];	/* pointer to JSAMPLE row[s] */
-  int row_stride;		/* physical row width in image buffer */
-
-  /* Step 1: allocate and initialize JPEG compression object */
-
-  /* We have to set up the error handler first, in case the initialization
-   * step fails.  (Unlikely, but it could happen if you are out of memory.)
-   * This routine fills in the contents of struct jerr, and returns jerr's
-   * address which we place into the link field in cinfo.
-   */
-  cinfo.err = jpeg_std_error(&jerr);
-  /* Now we can initialize the JPEG compression object. */
-  jpeg_create_compress(&cinfo);
-
-  /* Step 2: specify data destination (eg, a file) */
-  /* Note: steps 2 and 3 can be done in either order. */
-
-  /* Here we use the library-supplied code to send compressed data to a
-   * stdio stream.  You can also write your own code to do something else.
-   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
-   * requires it in order to write binary files.
-   */
-  if ((outfile = fopen(filename, "wb")) == NULL) {
-    fprintf(stderr, "can't open %s\n", filename);
-    exit(1);
-  }
-  jpeg_stdio_dest(&cinfo, outfile);
-
-  /* Step 3: set parameters for compression */
-
-  /* First we supply a description of the input image.
-   * Four fields of the cinfo struct must be filled in:
-   */
-  cinfo.image_width = image_width; 	/* image width and height, in pixels */
-  cinfo.image_height = image_height;
-  cinfo.input_components = 3;		/* # of color components per pixel */
-  cinfo.in_color_space = JCS_RGB; 	/* colorspace of input image */
-  /* Now use the library's routine to set default compression parameters.
-   * (You must set at least cinfo.in_color_space before calling this,
-   * since the defaults depend on the source color space.)
-   */
-  jpeg_set_defaults(&cinfo);
-  /* Now you can set any non-default parameters you wish to.
-   * Here we just illustrate the use of quality (quantization table) scaling:
-   */
-  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
-
-  /* Step 4: Start compressor */
-
-  /* TRUE ensures that we will write a complete interchange-JPEG file.
-   * Pass TRUE unless you are very sure of what you're doing.
-   */
-  jpeg_start_compress(&cinfo, TRUE);
-
-  /* Step 5: while (scan lines remain to be written) */
-  /*           jpeg_write_scanlines(...); */
-
-  /* Here we use the library's state variable cinfo.next_scanline as the
-   * loop counter, so that we don't have to keep track ourselves.
-   * To keep things simple, we pass one scanline per call; you can pass
-   * more if you wish, though.
-   */
-  row_stride = image_width * 3;	/* JSAMPLEs per row in image_buffer */
-
-  while (cinfo.next_scanline < cinfo.image_height) {
-    /* jpeg_write_scanlines expects an array of pointers to scanlines.
-     * Here the array is only one element long, but you could pass
-     * more than one scanline at a time if that's more convenient.
-     */
-    row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
-    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
-  }
-
-  /* Step 6: Finish compression */
-
-  jpeg_finish_compress(&cinfo);
-  /* After finish_compress, we can close the output file. */
-  fclose(outfile);
-
-  /* Step 7: release JPEG compression object */
-
-  /* This is an important step since it will release a good deal of memory. */
-  jpeg_destroy_compress(&cinfo);
-
-  /* And we're done! */
-}
-
-
-/*
- * SOME FINE POINTS:
- *
- * In the above loop, we ignored the return value of jpeg_write_scanlines,
- * which is the number of scanlines actually written.  We could get away
- * with this because we were only relying on the value of cinfo.next_scanline,
- * which will be incremented correctly.  If you maintain additional loop
- * variables then you should be careful to increment them properly.
- * Actually, for output to a stdio stream you needn't worry, because
- * then jpeg_write_scanlines will write all the lines passed (or else exit
- * with a fatal error).  Partial writes can only occur if you use a data
- * destination module that can demand suspension of the compressor.
- * (If you don't know what that's for, you don't need it.)
- *
- * If the compressor requires full-image buffers (for entropy-coding
- * optimization or a multi-scan JPEG file), it will create temporary
- * files for anything that doesn't fit within the maximum-memory setting.
- * (Note that temp files are NOT needed if you use the default parameters.)
- * On some systems you may need to set up a signal handler to ensure that
- * temporary files are deleted if the program is interrupted.  See libjpeg.doc.
- *
- * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG
- * files to be compatible with everyone else's.  If you cannot readily read
- * your data in that order, you'll need an intermediate array to hold the
- * image.  See rdtarga.c or rdbmp.c for examples of handling bottom-to-top
- * source data using the JPEG code's internal virtual-array mechanisms.
- */
-
-
-
-/******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/
-
-/* This half of the example shows how to read data from the JPEG decompressor.
- * It's a bit more refined than the above, in that we show:
- *   (a) how to modify the JPEG library's standard error-reporting behavior;
- *   (b) how to allocate workspace using the library's memory manager.
- *
- * Just to make this example a little different from the first one, we'll
- * assume that we do not intend to put the whole image into an in-memory
- * buffer, but to send it line-by-line someplace else.  We need a one-
- * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG
- * memory manager allocate it for us.  This approach is actually quite useful
- * because we don't need to remember to deallocate the buffer separately: it
- * will go away automatically when the JPEG object is cleaned up.
- */
-
-
-/*
- * ERROR HANDLING:
- *
- * The JPEG library's standard error handler (jerror.c) is divided into
- * several "methods" which you can override individually.  This lets you
- * adjust the behavior without duplicating a lot of code, which you might
- * have to update with each future release.
- *
- * Our example here shows how to override the "error_exit" method so that
- * control is returned to the library's caller when a fatal error occurs,
- * rather than calling exit() as the standard error_exit method does.
- *
- * We use C's setjmp/longjmp facility to return control.  This means that the
- * routine which calls the JPEG library must first execute a setjmp() call to
- * establish the return point.  We want the replacement error_exit to do a
- * longjmp().  But we need to make the setjmp buffer accessible to the
- * error_exit routine.  To do this, we make a private extension of the
- * standard JPEG error handler object.  (If we were using C++, we'd say we
- * were making a subclass of the regular error handler.)
- *
- * Here's the extended error handler struct:
- */
-
-struct my_error_mgr {
-  struct jpeg_error_mgr pub;	/* "public" fields */
-
-  jmp_buf setjmp_buffer;	/* for return to caller */
-};
-
-typedef struct my_error_mgr * my_error_ptr;
-
-/*
- * Here's the routine that will replace the standard error_exit method:
- */
-
-METHODDEF(void)
-my_error_exit (j_common_ptr cinfo)
-{
-  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
-  my_error_ptr myerr = (my_error_ptr) cinfo->err;
-
-  /* Always display the message. */
-  /* We could postpone this until after returning, if we chose. */
-  (*cinfo->err->output_message) (cinfo);
-
-  /* Return control to the setjmp point */
-  longjmp(myerr->setjmp_buffer, 1);
-}
-
-
-/*
- * Sample routine for JPEG decompression.  We assume that the source file name
- * is passed in.  We want to return 1 on success, 0 on error.
- */
-
-
-GLOBAL(int)
-read_JPEG_file (char * filename)
-{
-  /* This struct contains the JPEG decompression parameters and pointers to
-   * working space (which is allocated as needed by the JPEG library).
-   */
-  struct jpeg_decompress_struct cinfo;
-  /* We use our private extension JPEG error handler.
-   * Note that this struct must live as long as the main JPEG parameter
-   * struct, to avoid dangling-pointer problems.
-   */
-  struct my_error_mgr jerr;
-  /* More stuff */
-  FILE * infile;		/* source file */
-  JSAMPARRAY buffer;		/* Output row buffer */
-  int row_stride;		/* physical row width in output buffer */
-
-  /* In this example we want to open the input file before doing anything else,
-   * so that the setjmp() error recovery below can assume the file is open.
-   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
-   * requires it in order to read binary files.
-   */
-
-  if ((infile = fopen(filename, "rb")) == NULL) {
-    fprintf(stderr, "can't open %s\n", filename);
-    return 0;
-  }
-
-  /* Step 1: allocate and initialize JPEG decompression object */
-
-  /* We set up the normal JPEG error routines, then override error_exit. */
-  cinfo.err = jpeg_std_error(&jerr.pub);
-  jerr.pub.error_exit = my_error_exit;
-  /* Establish the setjmp return context for my_error_exit to use. */
-  if (setjmp(jerr.setjmp_buffer)) {
-    /* If we get here, the JPEG code has signaled an error.
-     * We need to clean up the JPEG object, close the input file, and return.
-     */
-    jpeg_destroy_decompress(&cinfo);
-    fclose(infile);
-    return 0;
-  }
-  /* Now we can initialize the JPEG decompression object. */
-  jpeg_create_decompress(&cinfo);
-
-  /* Step 2: specify data source (eg, a file) */
-
-  jpeg_stdio_src(&cinfo, infile);
-
-  /* Step 3: read file parameters with jpeg_read_header() */
-
-  (void) jpeg_read_header(&cinfo, TRUE);
-  /* We can ignore the return value from jpeg_read_header since
-   *   (a) suspension is not possible with the stdio data source, and
-   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
-   * See libjpeg.doc for more info.
-   */
-
-  /* Step 4: set parameters for decompression */
-
-  /* In this example, we don't need to change any of the defaults set by
-   * jpeg_read_header(), so we do nothing here.
-   */
-
-  /* Step 5: Start decompressor */
-
-  (void) jpeg_start_decompress(&cinfo);
-  /* We can ignore the return value since suspension is not possible
-   * with the stdio data source.
-   */
-
-  /* We may need to do some setup of our own at this point before reading
-   * the data.  After jpeg_start_decompress() we have the correct scaled
-   * output image dimensions available, as well as the output colormap
-   * if we asked for color quantization.
-   * In this example, we need to make an output work buffer of the right size.
-   */ 
-  /* JSAMPLEs per row in output buffer */
-  row_stride = cinfo.output_width * cinfo.output_components;
-  /* Make a one-row-high sample array that will go away when done with image */
-  buffer = (*cinfo.mem->alloc_sarray)
-		((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
-
-  /* Step 6: while (scan lines remain to be read) */
-  /*           jpeg_read_scanlines(...); */
-
-  /* Here we use the library's state variable cinfo.output_scanline as the
-   * loop counter, so that we don't have to keep track ourselves.
-   */
-  while (cinfo.output_scanline < cinfo.output_height) {
-    /* jpeg_read_scanlines expects an array of pointers to scanlines.
-     * Here the array is only one element long, but you could ask for
-     * more than one scanline at a time if that's more convenient.
-     */
-    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
-    /* Assume put_scanline_someplace wants a pointer and sample count. */
-    put_scanline_someplace(buffer[0], row_stride);
-  }
-
-  /* Step 7: Finish decompression */
-
-  (void) jpeg_finish_decompress(&cinfo);
-  /* We can ignore the return value since suspension is not possible
-   * with the stdio data source.
-   */
-
-  /* Step 8: Release JPEG decompression object */
-
-  /* This is an important step since it will release a good deal of memory. */
-  jpeg_destroy_decompress(&cinfo);
-
-  /* After finish_decompress, we can close the input file.
-   * Here we postpone it until after no more JPEG errors are possible,
-   * so as to simplify the setjmp error logic above.  (Actually, I don't
-   * think that jpeg_destroy can do an error exit, but why assume anything...)
-   */
-  fclose(infile);
-
-  /* At this point you may want to check to see whether any corrupt-data
-   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
-   */
-
-  /* And we're done! */
-  return 1;
-}
-
-
-/*
- * SOME FINE POINTS:
- *
- * In the above code, we ignored the return value of jpeg_read_scanlines,
- * which is the number of scanlines actually read.  We could get away with
- * this because we asked for only one line at a time and we weren't using
- * a suspending data source.  See libjpeg.doc for more info.
- *
- * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress();
- * we should have done it beforehand to ensure that the space would be
- * counted against the JPEG max_memory setting.  In some systems the above
- * code would risk an out-of-memory error.  However, in general we don't
- * know the output image dimensions before jpeg_start_decompress(), unless we
- * call jpeg_calc_output_dimensions().  See libjpeg.doc for more about this.
- *
- * Scanlines are returned in the same order as they appear in the JPEG file,
- * which is standardly top-to-bottom.  If you must emit data bottom-to-top,
- * you can use one of the virtual arrays provided by the JPEG memory manager
- * to invert the data.  See wrbmp.c for an example.
- *
- * As with compression, some operating modes may require temporary files.
- * On some systems you may need to set up a signal handler to ensure that
- * temporary files are deleted if the program is interrupted.  See libjpeg.doc.
- */
+/*

+ * example.c

+ *

+ * This file illustrates how to use the IJG code as a subroutine library

+ * to read or write JPEG image files.  You should look at this code in

+ * conjunction with the documentation file libjpeg.doc.

+ *

+ * This code will not do anything useful as-is, but it may be helpful as a

+ * skeleton for constructing routines that call the JPEG library.  

+ *

+ * We present these routines in the same coding style used in the JPEG code

+ * (ANSI function definitions, etc); but you are of course free to code your

+ * routines in a different style if you prefer.

+ */

+

+#include <stdio.h>

+

+/*

+ * Include file for users of JPEG library.

+ * You will need to have included system headers that define at least

+ * the typedefs FILE and size_t before you can include jpeglib.h.

+ * (stdio.h is sufficient on ANSI-conforming systems.)

+ * You may also wish to include "jerror.h".

+ */

+

+#include "jpeglib.h"

+

+/*

+ * <setjmp.h> is used for the optional error recovery mechanism shown in

+ * the second part of the example.

+ */

+

+#include <setjmp.h>

+

+

+

+/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/

+

+/* This half of the example shows how to feed data into the JPEG compressor.

+ * We present a minimal version that does not worry about refinements such

+ * as error recovery (the JPEG code will just exit() if it gets an error).

+ */

+

+

+/*

+ * IMAGE DATA FORMATS:

+ *

+ * The standard input image format is a rectangular array of pixels, with

+ * each pixel having the same number of "component" values (color channels).

+ * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars).

+ * If you are working with color data, then the color values for each pixel

+ * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit

+ * RGB color.

+ *

+ * For this example, we'll assume that this data structure matches the way

+ * our application has stored the image in memory, so we can just pass a

+ * pointer to our image buffer.  In particular, let's say that the image is

+ * RGB color and is described by:

+ */

+

+extern JSAMPLE * image_buffer;	/* Points to large array of R,G,B-order data */

+extern int image_height;	/* Number of rows in image */

+extern int image_width;		/* Number of columns in image */

+

+

+/*

+ * Sample routine for JPEG compression.  We assume that the target file name

+ * and a compression quality factor are passed in.

+ */

+

+GLOBAL(void)

+write_JPEG_file (char * filename, int quality)

+{

+  /* This struct contains the JPEG compression parameters and pointers to

+   * working space (which is allocated as needed by the JPEG library).

+   * It is possible to have several such structures, representing multiple

+   * compression/decompression processes, in existence at once.  We refer

+   * to any one struct (and its associated working data) as a "JPEG object".

+   */

+  struct jpeg_compress_struct cinfo;

+  /* This struct represents a JPEG error handler.  It is declared separately

+   * because applications often want to supply a specialized error handler

+   * (see the second half of this file for an example).  But here we just

+   * take the easy way out and use the standard error handler, which will

+   * print a message on stderr and call exit() if compression fails.

+   * Note that this struct must live as long as the main JPEG parameter

+   * struct, to avoid dangling-pointer problems.

+   */

+  struct jpeg_error_mgr jerr;

+  /* More stuff */

+  FILE * outfile;		/* target file */

+  JSAMPROW row_pointer[1];	/* pointer to JSAMPLE row[s] */

+  int row_stride;		/* physical row width in image buffer */

+

+  /* Step 1: allocate and initialize JPEG compression object */

+

+  /* We have to set up the error handler first, in case the initialization

+   * step fails.  (Unlikely, but it could happen if you are out of memory.)

+   * This routine fills in the contents of struct jerr, and returns jerr's

+   * address which we place into the link field in cinfo.

+   */

+  cinfo.err = jpeg_std_error(&jerr);

+  /* Now we can initialize the JPEG compression object. */

+  jpeg_create_compress(&cinfo);

+

+  /* Step 2: specify data destination (eg, a file) */

+  /* Note: steps 2 and 3 can be done in either order. */

+

+  /* Here we use the library-supplied code to send compressed data to a

+   * stdio stream.  You can also write your own code to do something else.

+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that

+   * requires it in order to write binary files.

+   */

+  if ((outfile = fopen(filename, "wb")) == NULL) {

+    fprintf(stderr, "can't open %s\n", filename);

+    exit(1);

+  }

+  jpeg_stdio_dest(&cinfo, outfile);

+

+  /* Step 3: set parameters for compression */

+

+  /* First we supply a description of the input image.

+   * Four fields of the cinfo struct must be filled in:

+   */

+  cinfo.image_width = image_width; 	/* image width and height, in pixels */

+  cinfo.image_height = image_height;

+  cinfo.input_components = 3;		/* # of color components per pixel */

+  cinfo.in_color_space = JCS_RGB; 	/* colorspace of input image */

+  /* Now use the library's routine to set default compression parameters.

+   * (You must set at least cinfo.in_color_space before calling this,

+   * since the defaults depend on the source color space.)

+   */

+  jpeg_set_defaults(&cinfo);

+  /* Now you can set any non-default parameters you wish to.

+   * Here we just illustrate the use of quality (quantization table) scaling:

+   */

+  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);

+

+  /* Step 4: Start compressor */

+

+  /* TRUE ensures that we will write a complete interchange-JPEG file.

+   * Pass TRUE unless you are very sure of what you're doing.

+   */

+  jpeg_start_compress(&cinfo, TRUE);

+

+  /* Step 5: while (scan lines remain to be written) */

+  /*           jpeg_write_scanlines(...); */

+

+  /* Here we use the library's state variable cinfo.next_scanline as the

+   * loop counter, so that we don't have to keep track ourselves.

+   * To keep things simple, we pass one scanline per call; you can pass

+   * more if you wish, though.

+   */

+  row_stride = image_width * 3;	/* JSAMPLEs per row in image_buffer */

+

+  while (cinfo.next_scanline < cinfo.image_height) {

+    /* jpeg_write_scanlines expects an array of pointers to scanlines.

+     * Here the array is only one element long, but you could pass

+     * more than one scanline at a time if that's more convenient.

+     */

+    row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];

+    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);

+  }

+

+  /* Step 6: Finish compression */

+

+  jpeg_finish_compress(&cinfo);

+  /* After finish_compress, we can close the output file. */

+  fclose(outfile);

+

+  /* Step 7: release JPEG compression object */

+

+  /* This is an important step since it will release a good deal of memory. */

+  jpeg_destroy_compress(&cinfo);

+

+  /* And we're done! */

+}

+

+

+/*

+ * SOME FINE POINTS:

+ *

+ * In the above loop, we ignored the return value of jpeg_write_scanlines,

+ * which is the number of scanlines actually written.  We could get away

+ * with this because we were only relying on the value of cinfo.next_scanline,

+ * which will be incremented correctly.  If you maintain additional loop

+ * variables then you should be careful to increment them properly.

+ * Actually, for output to a stdio stream you needn't worry, because

+ * then jpeg_write_scanlines will write all the lines passed (or else exit

+ * with a fatal error).  Partial writes can only occur if you use a data

+ * destination module that can demand suspension of the compressor.

+ * (If you don't know what that's for, you don't need it.)

+ *

+ * If the compressor requires full-image buffers (for entropy-coding

+ * optimization or a multi-scan JPEG file), it will create temporary

+ * files for anything that doesn't fit within the maximum-memory setting.

+ * (Note that temp files are NOT needed if you use the default parameters.)

+ * On some systems you may need to set up a signal handler to ensure that

+ * temporary files are deleted if the program is interrupted.  See libjpeg.doc.

+ *

+ * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG

+ * files to be compatible with everyone else's.  If you cannot readily read

+ * your data in that order, you'll need an intermediate array to hold the

+ * image.  See rdtarga.c or rdbmp.c for examples of handling bottom-to-top

+ * source data using the JPEG code's internal virtual-array mechanisms.

+ */

+

+

+

+/******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/

+

+/* This half of the example shows how to read data from the JPEG decompressor.

+ * It's a bit more refined than the above, in that we show:

+ *   (a) how to modify the JPEG library's standard error-reporting behavior;

+ *   (b) how to allocate workspace using the library's memory manager.

+ *

+ * Just to make this example a little different from the first one, we'll

+ * assume that we do not intend to put the whole image into an in-memory

+ * buffer, but to send it line-by-line someplace else.  We need a one-

+ * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG

+ * memory manager allocate it for us.  This approach is actually quite useful

+ * because we don't need to remember to deallocate the buffer separately: it

+ * will go away automatically when the JPEG object is cleaned up.

+ */

+

+

+/*

+ * ERROR HANDLING:

+ *

+ * The JPEG library's standard error handler (jerror.c) is divided into

+ * several "methods" which you can override individually.  This lets you

+ * adjust the behavior without duplicating a lot of code, which you might

+ * have to update with each future release.

+ *

+ * Our example here shows how to override the "error_exit" method so that

+ * control is returned to the library's caller when a fatal error occurs,

+ * rather than calling exit() as the standard error_exit method does.

+ *

+ * We use C's setjmp/longjmp facility to return control.  This means that the

+ * routine which calls the JPEG library must first execute a setjmp() call to

+ * establish the return point.  We want the replacement error_exit to do a

+ * longjmp().  But we need to make the setjmp buffer accessible to the

+ * error_exit routine.  To do this, we make a private extension of the

+ * standard JPEG error handler object.  (If we were using C++, we'd say we

+ * were making a subclass of the regular error handler.)

+ *

+ * Here's the extended error handler struct:

+ */

+

+struct my_error_mgr {

+  struct jpeg_error_mgr pub;	/* "public" fields */

+

+  jmp_buf setjmp_buffer;	/* for return to caller */

+};

+

+typedef struct my_error_mgr * my_error_ptr;

+

+/*

+ * Here's the routine that will replace the standard error_exit method:

+ */

+

+METHODDEF(void)

+my_error_exit (j_common_ptr cinfo)

+{

+  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */

+  my_error_ptr myerr = (my_error_ptr) cinfo->err;

+

+  /* Always display the message. */

+  /* We could postpone this until after returning, if we chose. */

+  (*cinfo->err->output_message) (cinfo);

+

+  /* Return control to the setjmp point */

+  longjmp(myerr->setjmp_buffer, 1);

+}

+

+

+/*

+ * Sample routine for JPEG decompression.  We assume that the source file name

+ * is passed in.  We want to return 1 on success, 0 on error.

+ */

+

+

+GLOBAL(int)

+read_JPEG_file (char * filename)

+{

+  /* This struct contains the JPEG decompression parameters and pointers to

+   * working space (which is allocated as needed by the JPEG library).

+   */

+  struct jpeg_decompress_struct cinfo;

+  /* We use our private extension JPEG error handler.

+   * Note that this struct must live as long as the main JPEG parameter

+   * struct, to avoid dangling-pointer problems.

+   */

+  struct my_error_mgr jerr;

+  /* More stuff */

+  FILE * infile;		/* source file */

+  JSAMPARRAY buffer;		/* Output row buffer */

+  int row_stride;		/* physical row width in output buffer */

+

+  /* In this example we want to open the input file before doing anything else,

+   * so that the setjmp() error recovery below can assume the file is open.

+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that

+   * requires it in order to read binary files.

+   */

+

+  if ((infile = fopen(filename, "rb")) == NULL) {

+    fprintf(stderr, "can't open %s\n", filename);

+    return 0;

+  }

+

+  /* Step 1: allocate and initialize JPEG decompression object */

+

+  /* We set up the normal JPEG error routines, then override error_exit. */

+  cinfo.err = jpeg_std_error(&jerr.pub);

+  jerr.pub.error_exit = my_error_exit;

+  /* Establish the setjmp return context for my_error_exit to use. */

+  if (setjmp(jerr.setjmp_buffer)) {

+    /* If we get here, the JPEG code has signaled an error.

+     * We need to clean up the JPEG object, close the input file, and return.

+     */

+    jpeg_destroy_decompress(&cinfo);

+    fclose(infile);

+    return 0;

+  }

+  /* Now we can initialize the JPEG decompression object. */

+  jpeg_create_decompress(&cinfo);

+

+  /* Step 2: specify data source (eg, a file) */

+

+  jpeg_stdio_src(&cinfo, infile);

+

+  /* Step 3: read file parameters with jpeg_read_header() */

+

+  (void) jpeg_read_header(&cinfo, TRUE);

+  /* We can ignore the return value from jpeg_read_header since

+   *   (a) suspension is not possible with the stdio data source, and

+   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.

+   * See libjpeg.doc for more info.

+   */

+

+  /* Step 4: set parameters for decompression */

+

+  /* In this example, we don't need to change any of the defaults set by

+   * jpeg_read_header(), so we do nothing here.

+   */

+

+  /* Step 5: Start decompressor */

+

+  (void) jpeg_start_decompress(&cinfo);

+  /* We can ignore the return value since suspension is not possible

+   * with the stdio data source.

+   */

+

+  /* We may need to do some setup of our own at this point before reading

+   * the data.  After jpeg_start_decompress() we have the correct scaled

+   * output image dimensions available, as well as the output colormap

+   * if we asked for color quantization.

+   * In this example, we need to make an output work buffer of the right size.

+   */ 

+  /* JSAMPLEs per row in output buffer */

+  row_stride = cinfo.output_width * cinfo.output_components;

+  /* Make a one-row-high sample array that will go away when done with image */

+  buffer = (*cinfo.mem->alloc_sarray)

+		((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);

+

+  /* Step 6: while (scan lines remain to be read) */

+  /*           jpeg_read_scanlines(...); */

+

+  /* Here we use the library's state variable cinfo.output_scanline as the

+   * loop counter, so that we don't have to keep track ourselves.

+   */

+  while (cinfo.output_scanline < cinfo.output_height) {

+    /* jpeg_read_scanlines expects an array of pointers to scanlines.

+     * Here the array is only one element long, but you could ask for

+     * more than one scanline at a time if that's more convenient.

+     */

+    (void) jpeg_read_scanlines(&cinfo, buffer, 1);

+    /* Assume put_scanline_someplace wants a pointer and sample count. */

+    put_scanline_someplace(buffer[0], row_stride);

+  }

+

+  /* Step 7: Finish decompression */

+

+  (void) jpeg_finish_decompress(&cinfo);

+  /* We can ignore the return value since suspension is not possible

+   * with the stdio data source.

+   */

+

+  /* Step 8: Release JPEG decompression object */

+

+  /* This is an important step since it will release a good deal of memory. */

+  jpeg_destroy_decompress(&cinfo);

+

+  /* After finish_decompress, we can close the input file.

+   * Here we postpone it until after no more JPEG errors are possible,

+   * so as to simplify the setjmp error logic above.  (Actually, I don't

+   * think that jpeg_destroy can do an error exit, but why assume anything...)

+   */

+  fclose(infile);

+

+  /* At this point you may want to check to see whether any corrupt-data

+   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).

+   */

+

+  /* And we're done! */

+  return 1;

+}

+

+

+/*

+ * SOME FINE POINTS:

+ *

+ * In the above code, we ignored the return value of jpeg_read_scanlines,

+ * which is the number of scanlines actually read.  We could get away with

+ * this because we asked for only one line at a time and we weren't using

+ * a suspending data source.  See libjpeg.doc for more info.

+ *

+ * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress();

+ * we should have done it beforehand to ensure that the space would be

+ * counted against the JPEG max_memory setting.  In some systems the above

+ * code would risk an out-of-memory error.  However, in general we don't

+ * know the output image dimensions before jpeg_start_decompress(), unless we

+ * call jpeg_calc_output_dimensions().  See libjpeg.doc for more about this.

+ *

+ * Scanlines are returned in the same order as they appear in the JPEG file,

+ * which is standardly top-to-bottom.  If you must emit data bottom-to-top,

+ * you can use one of the virtual arrays provided by the JPEG memory manager

+ * to invert the data.  See wrbmp.c for an example.

+ *

+ * As with compression, some operating modes may require temporary files.

+ * On some systems you may need to set up a signal handler to ensure that

+ * temporary files are deleted if the program is interrupted.  See libjpeg.doc.

+ */

diff --git a/test/monniaux/jpeg-6b/jccoefct.c b/test/monniaux/jpeg-6b/jccoefct.c
index 48bb2933..e0cb42a4 100644
--- a/test/monniaux/jpeg-6b/jccoefct.c
+++ b/test/monniaux/jpeg-6b/jccoefct.c
@@ -301,7 +301,7 @@ compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
      */
     if (coef->iMCU_row_num == last_iMCU_row) {
       blocks_across += ndummy;	/* include lower right corner */
-      MCUs_across = blocks_across / h_samp_factor;
+      MCUs_across = INT_DIV(blocks_across, h_samp_factor);
       for (block_row = block_rows; block_row < compptr->v_samp_factor;
 	   block_row++) {
 	thisblockrow = buffer[block_row];
diff --git a/test/monniaux/jpeg-6b/jcdctmgr.c b/test/monniaux/jpeg-6b/jcdctmgr.c
index 61fa79b9..b85b0832 100644
--- a/test/monniaux/jpeg-6b/jcdctmgr.c
+++ b/test/monniaux/jpeg-6b/jcdctmgr.c
@@ -244,9 +244,9 @@ forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
 	 * If your machine's division is fast enough, define FAST_DIVIDE.
 	 */
 #ifdef FAST_DIVIDE
-#define DIVIDE_BY(a,b)	a /= b
+#define DIVIDE_BY(a,b)	a = INT_DIV(a, b)
 #else
-#define DIVIDE_BY(a,b)	if (a >= b) a /= b; else a = 0
+#define DIVIDE_BY(a,b)	if (a >= b) a = INT_DIV(a, b); else a = 0
 #endif
 	if (temp < 0) {
 	  temp = -temp;
diff --git a/test/monniaux/jpeg-6b/jconfig.h b/test/monniaux/jpeg-6b/jconfig.h
index e42ea31b..9f41f022 100644
--- a/test/monniaux/jpeg-6b/jconfig.h
+++ b/test/monniaux/jpeg-6b/jconfig.h
@@ -33,13 +33,16 @@ extern long long __compcert_i64_sdiv(long long a, long long b);
 extern long long __compcert_i64_smod(long long a, long long b);
 
 #define INT_UMOD(a, b) __compcert_i64_smod(a, b)
+#define INT_MOD(a, b) __compcert_i64_smod(a, b)
 #define INT_UDIV(a, b) __compcert_i64_sdiv(a, b)
 #define INT_DIV(a, b) __compcert_i64_sdiv(a, b)
 #define LONG_DIV(a, b) __compcert_i64_sdiv(a, b)
 
 #define KILL_TAIL_CALL() { int x=1; }
+
 #else
 #define INT_UMOD(a, b) ((a) % (b))
+#define INT_MOD(a, b) ((a) % (b))
 #define INT_UDIV(a, b) ((a) / (b))
 #define INT_DIV(a, b) ((a) / (b))
 #define LONG_DIV(a, b) ((a) / (b))
diff --git a/test/monniaux/jpeg-6b/jcsample.c b/test/monniaux/jpeg-6b/jcsample.c
index d2693198..5cd42abd 100644
--- a/test/monniaux/jpeg-6b/jcsample.c
+++ b/test/monniaux/jpeg-6b/jcsample.c
@@ -516,4 +516,5 @@ jinit_downsampler (j_compress_ptr cinfo)
   if (cinfo->smoothing_factor && !smoothok)
     TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
 #endif
+  KILL_TAIL_CALL();
 }
diff --git a/test/monniaux/jpeg-6b/jdcoefct.c b/test/monniaux/jpeg-6b/jdcoefct.c
index c14c936f..54888720 100644
--- a/test/monniaux/jpeg-6b/jdcoefct.c
+++ b/test/monniaux/jpeg-6b/jdcoefct.c
@@ -349,7 +349,7 @@ decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
       block_rows = compptr->v_samp_factor;
     else {
       /* NB: can't use last_row_height here; it is input-side-dependent! */
-      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      block_rows = (int) INT_MOD(compptr->height_in_blocks, compptr->v_samp_factor);
       if (block_rows == 0) block_rows = compptr->v_samp_factor;
     }
     inverse_DCT = cinfo->idct->inverse_DCT[ci];
@@ -508,7 +508,7 @@ decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
       last_row = FALSE;
     } else {
       /* NB: can't use last_row_height here; it is input-side-dependent! */
-      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      block_rows = (int) INT_MOD(compptr->height_in_blocks, compptr->v_samp_factor);
       if (block_rows == 0) block_rows = compptr->v_samp_factor;
       access_rows = block_rows; /* this iMCU row only */
       last_row = TRUE;
diff --git a/test/monniaux/jpeg-6b/jdinput.c b/test/monniaux/jpeg-6b/jdinput.c
index 0c2ac8f1..8a676164 100644
--- a/test/monniaux/jpeg-6b/jdinput.c
+++ b/test/monniaux/jpeg-6b/jdinput.c
@@ -143,7 +143,7 @@ per_scan_setup (j_decompress_ptr cinfo)
     /* For noninterleaved scans, it is convenient to define last_row_height
      * as the number of block rows present in the last iMCU row.
      */
-    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+    tmp = (int) INT_MOD(compptr->height_in_blocks, compptr->v_samp_factor);
     if (tmp == 0) tmp = compptr->v_samp_factor;
     compptr->last_row_height = tmp;
     
@@ -176,10 +176,10 @@ per_scan_setup (j_decompress_ptr cinfo)
       compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
       compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size;
       /* Figure number of non-dummy blocks in last MCU column & row */
-      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+      tmp = (int) INT_MOD(compptr->width_in_blocks, compptr->MCU_width);
       if (tmp == 0) tmp = compptr->MCU_width;
       compptr->last_col_width = tmp;
-      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+      tmp = (int) INT_MOD(compptr->height_in_blocks, compptr->MCU_height);
       if (tmp == 0) tmp = compptr->MCU_height;
       compptr->last_row_height = tmp;
       /* Prepare array describing MCU composition */
diff --git a/test/monniaux/jpeg-6b/jdmainct.c b/test/monniaux/jpeg-6b/jdmainct.c
index e78bd8a4..4d49d26f 100644
--- a/test/monniaux/jpeg-6b/jdmainct.c
+++ b/test/monniaux/jpeg-6b/jdmainct.c
@@ -283,7 +283,7 @@ set_bottom_pointers (j_decompress_ptr cinfo)
     iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
     rgroup = INT_DIV(iMCUheight, cinfo->min_DCT_scaled_size);
     /* Count nondummy sample rows remaining for this component */
-    rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
+    rows_left = (int) INT_MOD(compptr->downsampled_height, (JDIMENSION) iMCUheight);
     if (rows_left == 0) rows_left = iMCUheight;
     /* Count nondummy row groups.  Should get same answer for each component,
      * so we need only do it once.
@@ -467,6 +467,7 @@ process_data_crank_post (j_decompress_ptr cinfo,
   (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
 				     (JDIMENSION *) NULL, (JDIMENSION) 0,
 				     output_buf, out_row_ctr, out_rows_avail);
+  KILL_TAIL_CALL();
 }
 
 #endif /* QUANT_2PASS_SUPPORTED */
diff --git a/test/monniaux/jpeg-6b/jdsample.c b/test/monniaux/jpeg-6b/jdsample.c
index 80ffefb2..96d56f0c 100644
--- a/test/monniaux/jpeg-6b/jdsample.c
+++ b/test/monniaux/jpeg-6b/jdsample.c
@@ -428,10 +428,10 @@ jinit_upsampler (j_decompress_ptr cinfo)
     /* Compute size of an "input group" after IDCT scaling.  This many samples
      * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
      */
-    h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
-		 cinfo->min_DCT_scaled_size;
-    v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
-		 cinfo->min_DCT_scaled_size;
+    h_in_group = INT_DIV((compptr->h_samp_factor * compptr->DCT_scaled_size),
+			 cinfo->min_DCT_scaled_size);
+    v_in_group = INT_DIV((compptr->v_samp_factor * compptr->DCT_scaled_size),
+			 cinfo->min_DCT_scaled_size);
     h_out_group = cinfo->max_h_samp_factor;
     v_out_group = cinfo->max_v_samp_factor;
     upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
@@ -459,12 +459,12 @@ jinit_upsampler (j_decompress_ptr cinfo)
 	upsample->pub.need_context_rows = TRUE;
       } else
 	upsample->methods[ci] = h2v2_upsample;
-    } else if ((h_out_group % h_in_group) == 0 &&
-	       (v_out_group % v_in_group) == 0) {
+    } else if (INT_MOD(h_out_group, h_in_group) == 0 &&
+	       INT_MOD(v_out_group, v_in_group) == 0) {
       /* Generic integral-factors upsampling method */
       upsample->methods[ci] = int_upsample;
-      upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
-      upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
+      upsample->h_expand[ci] = (UINT8) INT_DIV(h_out_group, h_in_group);
+      upsample->v_expand[ci] = (UINT8) INT_DIV(v_out_group, v_in_group);
     } else
       ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
     if (need_buffer) {
diff --git a/test/monniaux/jpeg-6b/jerror.c b/test/monniaux/jpeg-6b/jerror.c
index a60ff693..c98aed76 100644
--- a/test/monniaux/jpeg-6b/jerror.c
+++ b/test/monniaux/jpeg-6b/jerror.c
@@ -1,253 +1,252 @@
-/*
- * jerror.c
- *
- * Copyright (C) 1991-1998, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains simple error-reporting and trace-message routines.
- * These are suitable for Unix-like systems and others where writing to
- * stderr is the right thing to do.  Many applications will want to replace
- * some or all of these routines.
- *
- * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
- * you get a Windows-specific hack to display error messages in a dialog box.
- * It ain't much, but it beats dropping error messages into the bit bucket,
- * which is what happens to output to stderr under most Windows C compilers.
- *
- * These routines are used by both the compression and decompression code.
- */
-
-/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jversion.h"
-#include "jerror.h"
-
-#ifdef USE_WINDOWS_MESSAGEBOX
-#include <windows.h>
-#endif
-
-#ifndef EXIT_FAILURE		/* define exit() codes if not provided */
-#define EXIT_FAILURE  1
-#endif
-
-
-/*
- * Create the message string table.
- * We do this from the master message list in jerror.h by re-reading
- * jerror.h with a suitable definition for macro JMESSAGE.
- * The message table is made an external symbol just in case any applications
- * want to refer to it directly.
- */
-
-#ifdef NEED_SHORT_EXTERNAL_NAMES
-#define jpeg_std_message_table	jMsgTable
-#endif
-
-#define JMESSAGE(code,string)	string ,
-
-const char * const jpeg_std_message_table[] = {
-#include "jerror.h"
-  NULL
-};
-
-
-/*
- * Error exit handler: must not return to caller.
- *
- * Applications may override this if they want to get control back after
- * an error.  Typically one would longjmp somewhere instead of exiting.
- * The setjmp buffer can be made a private field within an expanded error
- * handler object.  Note that the info needed to generate an error message
- * is stored in the error object, so you can generate the message now or
- * later, at your convenience.
- * You should make sure that the JPEG object is cleaned up (with jpeg_abort
- * or jpeg_destroy) at some point.
- */
-
-METHODDEF(void)
-error_exit (j_common_ptr cinfo)
-{
-  /* Always display the message */
-  (*cinfo->err->output_message) (cinfo);
-
-  /* Let the memory manager delete any temp files before we die */
-  jpeg_destroy(cinfo);
-
-  exit(EXIT_FAILURE);
-}
-
-
-/*
- * Actual output of an error or trace message.
- * Applications may override this method to send JPEG messages somewhere
- * other than stderr.
- *
- * On Windows, printing to stderr is generally completely useless,
- * so we provide optional code to produce an error-dialog popup.
- * Most Windows applications will still prefer to override this routine,
- * but if they don't, it'll do something at least marginally useful.
- *
- * NOTE: to use the library in an environment that doesn't support the
- * C stdio library, you may have to delete the call to fprintf() entirely,
- * not just not use this routine.
- */
-
-METHODDEF(void)
-output_message (j_common_ptr cinfo)
-{
-  char buffer[JMSG_LENGTH_MAX];
-
-  /* Create the message */
-  (*cinfo->err->format_message) (cinfo, buffer);
-
-#ifdef USE_WINDOWS_MESSAGEBOX
-  /* Display it in a message dialog box */
-  MessageBox(GetActiveWindow(), buffer, "JPEG Library Error",
-	     MB_OK | MB_ICONERROR);
-#else
-  /* Send it to stderr, adding a newline */
-  fprintf(stderr, "%s\n", buffer);
-#endif
-}
-
-
-/*
- * Decide whether to emit a trace or warning message.
- * msg_level is one of:
- *   -1: recoverable corrupt-data warning, may want to abort.
- *    0: important advisory messages (always display to user).
- *    1: first level of tracing detail.
- *    2,3,...: successively more detailed tracing messages.
- * An application might override this method if it wanted to abort on warnings
- * or change the policy about which messages to display.
- */
-
-METHODDEF(void)
-emit_message (j_common_ptr cinfo, int msg_level)
-{
-  struct jpeg_error_mgr * err = cinfo->err;
-
-  if (msg_level < 0) {
-    /* It's a warning message.  Since corrupt files may generate many warnings,
-     * the policy implemented here is to show only the first warning,
-     * unless trace_level >= 3.
-     */
-    if (err->num_warnings == 0 || err->trace_level >= 3)
-      (*err->output_message) (cinfo);
-    /* Always count warnings in num_warnings. */
-    err->num_warnings++;
-  } else {
-    /* It's a trace message.  Show it if trace_level >= msg_level. */
-    if (err->trace_level >= msg_level)
-      (*err->output_message) (cinfo);
-  }
-  KILL_TAIL_CALL();
-}
-
-
-/*
- * Format a message string for the most recent JPEG error or message.
- * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
- * characters.  Note that no '\n' character is added to the string.
- * Few applications should need to override this method.
- */
-
-METHODDEF(void)
-format_message (j_common_ptr cinfo, char * buffer)
-{
-  struct jpeg_error_mgr * err = cinfo->err;
-  int msg_code = err->msg_code;
-  const char * msgtext = NULL;
-  const char * msgptr;
-  char ch;
-  boolean isstring;
-
-  /* Look up message string in proper table */
-  if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
-    msgtext = err->jpeg_message_table[msg_code];
-  } else if (err->addon_message_table != NULL &&
-	     msg_code >= err->first_addon_message &&
-	     msg_code <= err->last_addon_message) {
-    msgtext = err->addon_message_table[msg_code - err->first_addon_message];
-  }
-
-  /* Defend against bogus message number */
-  if (msgtext == NULL) {
-    err->msg_parm.i[0] = msg_code;
-    msgtext = err->jpeg_message_table[0];
-  }
-
-  /* Check for string parameter, as indicated by %s in the message text */
-  isstring = FALSE;
-  msgptr = msgtext;
-  while ((ch = *msgptr++) != '\0') {
-    if (ch == '%') {
-      if (*msgptr == 's') isstring = TRUE;
-      break;
-    }
-  }
-
-  /* Format the message into the passed buffer */
-  if (isstring)
-    sprintf(buffer, msgtext, err->msg_parm.s);
-  else
-    sprintf(buffer, msgtext,
-	    err->msg_parm.i[0], err->msg_parm.i[1],
-	    err->msg_parm.i[2], err->msg_parm.i[3],
-	    err->msg_parm.i[4], err->msg_parm.i[5],
-	    err->msg_parm.i[6], err->msg_parm.i[7]);
-}
-
-
-/*
- * Reset error state variables at start of a new image.
- * This is called during compression startup to reset trace/error
- * processing to default state, without losing any application-specific
- * method pointers.  An application might possibly want to override
- * this method if it has additional error processing state.
- */
-
-METHODDEF(void)
-reset_error_mgr (j_common_ptr cinfo)
-{
-  cinfo->err->num_warnings = 0;
-  /* trace_level is not reset since it is an application-supplied parameter */
-  cinfo->err->msg_code = 0;	/* may be useful as a flag for "no error" */
-}
-
-
-/*
- * Fill in the standard error-handling methods in a jpeg_error_mgr object.
- * Typical call is:
- *	struct jpeg_compress_struct cinfo;
- *	struct jpeg_error_mgr err;
- *
- *	cinfo.err = jpeg_std_error(&err);
- * after which the application may override some of the methods.
- */
-
-GLOBAL(struct jpeg_error_mgr *)
-jpeg_std_error (struct jpeg_error_mgr * err)
-{
-  err->error_exit = error_exit;
-  err->emit_message = emit_message;
-  err->output_message = output_message;
-  err->format_message = format_message;
-  err->reset_error_mgr = reset_error_mgr;
-
-  err->trace_level = 0;		/* default = no tracing */
-  err->num_warnings = 0;	/* no warnings emitted yet */
-  err->msg_code = 0;		/* may be useful as a flag for "no error" */
-
-  /* Initialize message table pointers */
-  err->jpeg_message_table = jpeg_std_message_table;
-  err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
-
-  err->addon_message_table = NULL;
-  err->first_addon_message = 0;	/* for safety */
-  err->last_addon_message = 0;
-
-  return err;
-}
+/*

+ * jerror.c

+ *

+ * Copyright (C) 1991-1998, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains simple error-reporting and trace-message routines.

+ * These are suitable for Unix-like systems and others where writing to

+ * stderr is the right thing to do.  Many applications will want to replace

+ * some or all of these routines.

+ *

+ * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,

+ * you get a Windows-specific hack to display error messages in a dialog box.

+ * It ain't much, but it beats dropping error messages into the bit bucket,

+ * which is what happens to output to stderr under most Windows C compilers.

+ *

+ * These routines are used by both the compression and decompression code.

+ */

+

+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */

+#include "jinclude.h"

+#include "jpeglib.h"

+#include "jversion.h"

+#include "jerror.h"

+

+#ifdef USE_WINDOWS_MESSAGEBOX

+#include <windows.h>

+#endif

+

+#ifndef EXIT_FAILURE		/* define exit() codes if not provided */

+#define EXIT_FAILURE  1

+#endif

+

+

+/*

+ * Create the message string table.

+ * We do this from the master message list in jerror.h by re-reading

+ * jerror.h with a suitable definition for macro JMESSAGE.

+ * The message table is made an external symbol just in case any applications

+ * want to refer to it directly.

+ */

+

+#ifdef NEED_SHORT_EXTERNAL_NAMES

+#define jpeg_std_message_table	jMsgTable

+#endif

+

+#define JMESSAGE(code,string)	string ,

+

+const char * const jpeg_std_message_table[] = {

+#include "jerror.h"

+  NULL

+};

+

+

+/*

+ * Error exit handler: must not return to caller.

+ *

+ * Applications may override this if they want to get control back after

+ * an error.  Typically one would longjmp somewhere instead of exiting.

+ * The setjmp buffer can be made a private field within an expanded error

+ * handler object.  Note that the info needed to generate an error message

+ * is stored in the error object, so you can generate the message now or

+ * later, at your convenience.

+ * You should make sure that the JPEG object is cleaned up (with jpeg_abort

+ * or jpeg_destroy) at some point.

+ */

+

+METHODDEF(void)

+error_exit (j_common_ptr cinfo)

+{

+  /* Always display the message */

+  (*cinfo->err->output_message) (cinfo);

+

+  /* Let the memory manager delete any temp files before we die */

+  jpeg_destroy(cinfo);

+

+  exit(EXIT_FAILURE);

+}

+

+

+/*

+ * Actual output of an error or trace message.

+ * Applications may override this method to send JPEG messages somewhere

+ * other than stderr.

+ *

+ * On Windows, printing to stderr is generally completely useless,

+ * so we provide optional code to produce an error-dialog popup.

+ * Most Windows applications will still prefer to override this routine,

+ * but if they don't, it'll do something at least marginally useful.

+ *

+ * NOTE: to use the library in an environment that doesn't support the

+ * C stdio library, you may have to delete the call to fprintf() entirely,

+ * not just not use this routine.

+ */

+

+METHODDEF(void)

+output_message (j_common_ptr cinfo)

+{

+  char buffer[JMSG_LENGTH_MAX];

+

+  /* Create the message */

+  (*cinfo->err->format_message) (cinfo, buffer);

+

+#ifdef USE_WINDOWS_MESSAGEBOX

+  /* Display it in a message dialog box */

+  MessageBox(GetActiveWindow(), buffer, "JPEG Library Error",

+	     MB_OK | MB_ICONERROR);

+#else

+  /* Send it to stderr, adding a newline */

+  fprintf(stderr, "%s\n", buffer);

+#endif

+}

+

+

+/*

+ * Decide whether to emit a trace or warning message.

+ * msg_level is one of:

+ *   -1: recoverable corrupt-data warning, may want to abort.

+ *    0: important advisory messages (always display to user).

+ *    1: first level of tracing detail.

+ *    2,3,...: successively more detailed tracing messages.

+ * An application might override this method if it wanted to abort on warnings

+ * or change the policy about which messages to display.

+ */

+

+METHODDEF(void)

+emit_message (j_common_ptr cinfo, int msg_level)

+{

+  struct jpeg_error_mgr * err = cinfo->err;

+

+  if (msg_level < 0) {

+    /* It's a warning message.  Since corrupt files may generate many warnings,

+     * the policy implemented here is to show only the first warning,

+     * unless trace_level >= 3.

+     */

+    if (err->num_warnings == 0 || err->trace_level >= 3)

+      (*err->output_message) (cinfo);

+    /* Always count warnings in num_warnings. */

+    err->num_warnings++;

+  } else {

+    /* It's a trace message.  Show it if trace_level >= msg_level. */

+    if (err->trace_level >= msg_level)

+      (*err->output_message) (cinfo);

+  }

+}

+

+

+/*

+ * Format a message string for the most recent JPEG error or message.

+ * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX

+ * characters.  Note that no '\n' character is added to the string.

+ * Few applications should need to override this method.

+ */

+

+METHODDEF(void)

+format_message (j_common_ptr cinfo, char * buffer)

+{

+  struct jpeg_error_mgr * err = cinfo->err;

+  int msg_code = err->msg_code;

+  const char * msgtext = NULL;

+  const char * msgptr;

+  char ch;

+  boolean isstring;

+

+  /* Look up message string in proper table */

+  if (msg_code > 0 && msg_code <= err->last_jpeg_message) {

+    msgtext = err->jpeg_message_table[msg_code];

+  } else if (err->addon_message_table != NULL &&

+	     msg_code >= err->first_addon_message &&

+	     msg_code <= err->last_addon_message) {

+    msgtext = err->addon_message_table[msg_code - err->first_addon_message];

+  }

+

+  /* Defend against bogus message number */

+  if (msgtext == NULL) {

+    err->msg_parm.i[0] = msg_code;

+    msgtext = err->jpeg_message_table[0];

+  }

+

+  /* Check for string parameter, as indicated by %s in the message text */

+  isstring = FALSE;

+  msgptr = msgtext;

+  while ((ch = *msgptr++) != '\0') {

+    if (ch == '%') {

+      if (*msgptr == 's') isstring = TRUE;

+      break;

+    }

+  }

+

+  /* Format the message into the passed buffer */

+  if (isstring)

+    sprintf(buffer, msgtext, err->msg_parm.s);

+  else

+    sprintf(buffer, msgtext,

+	    err->msg_parm.i[0], err->msg_parm.i[1],

+	    err->msg_parm.i[2], err->msg_parm.i[3],

+	    err->msg_parm.i[4], err->msg_parm.i[5],

+	    err->msg_parm.i[6], err->msg_parm.i[7]);

+}

+

+

+/*

+ * Reset error state variables at start of a new image.

+ * This is called during compression startup to reset trace/error

+ * processing to default state, without losing any application-specific

+ * method pointers.  An application might possibly want to override

+ * this method if it has additional error processing state.

+ */

+

+METHODDEF(void)

+reset_error_mgr (j_common_ptr cinfo)

+{

+  cinfo->err->num_warnings = 0;

+  /* trace_level is not reset since it is an application-supplied parameter */

+  cinfo->err->msg_code = 0;	/* may be useful as a flag for "no error" */

+}

+

+

+/*

+ * Fill in the standard error-handling methods in a jpeg_error_mgr object.

+ * Typical call is:

+ *	struct jpeg_compress_struct cinfo;

+ *	struct jpeg_error_mgr err;

+ *

+ *	cinfo.err = jpeg_std_error(&err);

+ * after which the application may override some of the methods.

+ */

+

+GLOBAL(struct jpeg_error_mgr *)

+jpeg_std_error (struct jpeg_error_mgr * err)

+{

+  err->error_exit = error_exit;

+  err->emit_message = emit_message;

+  err->output_message = output_message;

+  err->format_message = format_message;

+  err->reset_error_mgr = reset_error_mgr;

+

+  err->trace_level = 0;		/* default = no tracing */

+  err->num_warnings = 0;	/* no warnings emitted yet */

+  err->msg_code = 0;		/* may be useful as a flag for "no error" */

+

+  /* Initialize message table pointers */

+  err->jpeg_message_table = jpeg_std_message_table;

+  err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;

+

+  err->addon_message_table = NULL;

+  err->first_addon_message = 0;	/* for safety */

+  err->last_addon_message = 0;

+

+  return err;

+}

diff --git a/test/monniaux/jpeg-6b/jmemmgr.c b/test/monniaux/jpeg-6b/jmemmgr.c
index 12ab0516..b636f1be 100644
--- a/test/monniaux/jpeg-6b/jmemmgr.c
+++ b/test/monniaux/jpeg-6b/jmemmgr.c
@@ -1,1119 +1,1118 @@
-/*
- * jmemmgr.c
- *
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains the JPEG system-independent memory management
- * routines.  This code is usable across a wide variety of machines; most
- * of the system dependencies have been isolated in a separate file.
- * The major functions provided here are:
- *   * pool-based allocation and freeing of memory;
- *   * policy decisions about how to divide available memory among the
- *     virtual arrays;
- *   * control logic for swapping virtual arrays between main memory and
- *     backing storage.
- * The separate system-dependent file provides the actual backing-storage
- * access code, and it contains the policy decision about how much total
- * main memory to use.
- * This file is system-dependent in the sense that some of its functions
- * are unnecessary in some systems.  For example, if there is enough virtual
- * memory so that backing storage will never be used, much of the virtual
- * array control logic could be removed.  (Of course, if you have that much
- * memory then you shouldn't care about a little bit of unused code...)
- */
-
-#define JPEG_INTERNALS
-#define AM_MEMORY_MANAGER	/* we define jvirt_Xarray_control structs */
-#include "jinclude.h"
-#include "jpeglib.h"
-#include "jmemsys.h"		/* import the system-dependent declarations */
-
-#ifndef NO_GETENV
-#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare getenv() */
-extern char * getenv JPP((const char * name));
-#endif
-#endif
-
-
-/*
- * Some important notes:
- *   The allocation routines provided here must never return NULL.
- *   They should exit to error_exit if unsuccessful.
- *
- *   It's not a good idea to try to merge the sarray and barray routines,
- *   even though they are textually almost the same, because samples are
- *   usually stored as bytes while coefficients are shorts or ints.  Thus,
- *   in machines where byte pointers have a different representation from
- *   word pointers, the resulting machine code could not be the same.
- */
-
-
-/*
- * Many machines require storage alignment: longs must start on 4-byte
- * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc()
- * always returns pointers that are multiples of the worst-case alignment
- * requirement, and we had better do so too.
- * There isn't any really portable way to determine the worst-case alignment
- * requirement.  This module assumes that the alignment requirement is
- * multiples of sizeof(ALIGN_TYPE).
- * By default, we define ALIGN_TYPE as double.  This is necessary on some
- * workstations (where doubles really do need 8-byte alignment) and will work
- * fine on nearly everything.  If your machine has lesser alignment needs,
- * you can save a few bytes by making ALIGN_TYPE smaller.
- * The only place I know of where this will NOT work is certain Macintosh
- * 680x0 compilers that define double as a 10-byte IEEE extended float.
- * Doing 10-byte alignment is counterproductive because longwords won't be
- * aligned well.  Put "#define ALIGN_TYPE long" in jconfig.h if you have
- * such a compiler.
- */
-
-#ifndef ALIGN_TYPE		/* so can override from jconfig.h */
-#define ALIGN_TYPE  double
-#endif
-
-
-/*
- * We allocate objects from "pools", where each pool is gotten with a single
- * request to jpeg_get_small() or jpeg_get_large().  There is no per-object
- * overhead within a pool, except for alignment padding.  Each pool has a
- * header with a link to the next pool of the same class.
- * Small and large pool headers are identical except that the latter's
- * link pointer must be FAR on 80x86 machines.
- * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE
- * field.  This forces the compiler to make SIZEOF(small_pool_hdr) a multiple
- * of the alignment requirement of ALIGN_TYPE.
- */
-
-typedef union small_pool_struct * small_pool_ptr;
-
-typedef union small_pool_struct {
-  struct {
-    small_pool_ptr next;	/* next in list of pools */
-    size_t bytes_used;		/* how many bytes already used within pool */
-    size_t bytes_left;		/* bytes still available in this pool */
-  } hdr;
-  ALIGN_TYPE dummy;		/* included in union to ensure alignment */
-} small_pool_hdr;
-
-typedef union large_pool_struct FAR * large_pool_ptr;
-
-typedef union large_pool_struct {
-  struct {
-    large_pool_ptr next;	/* next in list of pools */
-    size_t bytes_used;		/* how many bytes already used within pool */
-    size_t bytes_left;		/* bytes still available in this pool */
-  } hdr;
-  ALIGN_TYPE dummy;		/* included in union to ensure alignment */
-} large_pool_hdr;
-
-
-/*
- * Here is the full definition of a memory manager object.
- */
-
-typedef struct {
-  struct jpeg_memory_mgr pub;	/* public fields */
-
-  /* Each pool identifier (lifetime class) names a linked list of pools. */
-  small_pool_ptr small_list[JPOOL_NUMPOOLS];
-  large_pool_ptr large_list[JPOOL_NUMPOOLS];
-
-  /* Since we only have one lifetime class of virtual arrays, only one
-   * linked list is necessary (for each datatype).  Note that the virtual
-   * array control blocks being linked together are actually stored somewhere
-   * in the small-pool list.
-   */
-  jvirt_sarray_ptr virt_sarray_list;
-  jvirt_barray_ptr virt_barray_list;
-
-  /* This counts total space obtained from jpeg_get_small/large */
-  long total_space_allocated;
-
-  /* alloc_sarray and alloc_barray set this value for use by virtual
-   * array routines.
-   */
-  JDIMENSION last_rowsperchunk;	/* from most recent alloc_sarray/barray */
-} my_memory_mgr;
-
-typedef my_memory_mgr * my_mem_ptr;
-
-
-/*
- * The control blocks for virtual arrays.
- * Note that these blocks are allocated in the "small" pool area.
- * System-dependent info for the associated backing store (if any) is hidden
- * inside the backing_store_info struct.
- */
-
-struct jvirt_sarray_control {
-  JSAMPARRAY mem_buffer;	/* => the in-memory buffer */
-  JDIMENSION rows_in_array;	/* total virtual array height */
-  JDIMENSION samplesperrow;	/* width of array (and of memory buffer) */
-  JDIMENSION maxaccess;		/* max rows accessed by access_virt_sarray */
-  JDIMENSION rows_in_mem;	/* height of memory buffer */
-  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */
-  JDIMENSION cur_start_row;	/* first logical row # in the buffer */
-  JDIMENSION first_undef_row;	/* row # of first uninitialized row */
-  boolean pre_zero;		/* pre-zero mode requested? */
-  boolean dirty;		/* do current buffer contents need written? */
-  boolean b_s_open;		/* is backing-store data valid? */
-  jvirt_sarray_ptr next;	/* link to next virtual sarray control block */
-  backing_store_info b_s_info;	/* System-dependent control info */
-};
-
-struct jvirt_barray_control {
-  JBLOCKARRAY mem_buffer;	/* => the in-memory buffer */
-  JDIMENSION rows_in_array;	/* total virtual array height */
-  JDIMENSION blocksperrow;	/* width of array (and of memory buffer) */
-  JDIMENSION maxaccess;		/* max rows accessed by access_virt_barray */
-  JDIMENSION rows_in_mem;	/* height of memory buffer */
-  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */
-  JDIMENSION cur_start_row;	/* first logical row # in the buffer */
-  JDIMENSION first_undef_row;	/* row # of first uninitialized row */
-  boolean pre_zero;		/* pre-zero mode requested? */
-  boolean dirty;		/* do current buffer contents need written? */
-  boolean b_s_open;		/* is backing-store data valid? */
-  jvirt_barray_ptr next;	/* link to next virtual barray control block */
-  backing_store_info b_s_info;	/* System-dependent control info */
-};
-
-
-#ifdef MEM_STATS		/* optional extra stuff for statistics */
-
-LOCAL(void)
-print_mem_stats (j_common_ptr cinfo, int pool_id)
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  small_pool_ptr shdr_ptr;
-  large_pool_ptr lhdr_ptr;
-
-  /* Since this is only a debugging stub, we can cheat a little by using
-   * fprintf directly rather than going through the trace message code.
-   * This is helpful because message parm array can't handle longs.
-   */
-  fprintf(stderr, "Freeing pool %d, total space = %ld\n",
-	  pool_id, mem->total_space_allocated);
-
-  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;
-       lhdr_ptr = lhdr_ptr->hdr.next) {
-    fprintf(stderr, "  Large chunk used %ld\n",
-	    (long) lhdr_ptr->hdr.bytes_used);
-  }
-
-  for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;
-       shdr_ptr = shdr_ptr->hdr.next) {
-    fprintf(stderr, "  Small chunk used %ld free %ld\n",
-	    (long) shdr_ptr->hdr.bytes_used,
-	    (long) shdr_ptr->hdr.bytes_left);
-  }
-}
-
-#endif /* MEM_STATS */
-
-
-LOCAL(void)
-out_of_memory (j_common_ptr cinfo, int which)
-/* Report an out-of-memory error and stop execution */
-/* If we compiled MEM_STATS support, report alloc requests before dying */
-{
-#ifdef MEM_STATS
-  cinfo->err->trace_level = 2;	/* force self_destruct to report stats */
-#endif
-  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);
-  KILL_TAIL_CALL();
-}
-
-
-/*
- * Allocation of "small" objects.
- *
- * For these, we use pooled storage.  When a new pool must be created,
- * we try to get enough space for the current request plus a "slop" factor,
- * where the slop will be the amount of leftover space in the new pool.
- * The speed vs. space tradeoff is largely determined by the slop values.
- * A different slop value is provided for each pool class (lifetime),
- * and we also distinguish the first pool of a class from later ones.
- * NOTE: the values given work fairly well on both 16- and 32-bit-int
- * machines, but may be too small if longs are 64 bits or more.
- */
-
-static const size_t first_pool_slop[JPOOL_NUMPOOLS] = 
-{
-	1600,			/* first PERMANENT pool */
-	16000			/* first IMAGE pool */
-};
-
-static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = 
-{
-	0,			/* additional PERMANENT pools */
-	5000			/* additional IMAGE pools */
-};
-
-#define MIN_SLOP  50		/* greater than 0 to avoid futile looping */
-
-
-METHODDEF(void *)
-alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
-/* Allocate a "small" object */
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  small_pool_ptr hdr_ptr, prev_hdr_ptr;
-  char * data_ptr;
-  size_t odd_bytes, min_request, slop;
-
-  /* Check for unsatisfiable request (do now to ensure no overflow below) */
-  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))
-    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */
-
-  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
-  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
-  if (odd_bytes > 0)
-    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
-
-  /* See if space is available in any existing pool */
-  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
-    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
-  prev_hdr_ptr = NULL;
-  hdr_ptr = mem->small_list[pool_id];
-  while (hdr_ptr != NULL) {
-    if (hdr_ptr->hdr.bytes_left >= sizeofobject)
-      break;			/* found pool with enough space */
-    prev_hdr_ptr = hdr_ptr;
-    hdr_ptr = hdr_ptr->hdr.next;
-  }
-
-  /* Time to make a new pool? */
-  if (hdr_ptr == NULL) {
-    /* min_request is what we need now, slop is what will be leftover */
-    min_request = sizeofobject + SIZEOF(small_pool_hdr);
-    if (prev_hdr_ptr == NULL)	/* first pool in class? */
-      slop = first_pool_slop[pool_id];
-    else
-      slop = extra_pool_slop[pool_id];
-    /* Don't ask for more than MAX_ALLOC_CHUNK */
-    if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))
-      slop = (size_t) (MAX_ALLOC_CHUNK-min_request);
-    /* Try to get space, if fail reduce slop and try again */
-    for (;;) {
-      hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);
-      if (hdr_ptr != NULL)
-	break;
-      slop /= 2;
-      if (slop < MIN_SLOP)	/* give up when it gets real small */
-	out_of_memory(cinfo, 2); /* jpeg_get_small failed */
-    }
-    mem->total_space_allocated += min_request + slop;
-    /* Success, initialize the new pool header and add to end of list */
-    hdr_ptr->hdr.next = NULL;
-    hdr_ptr->hdr.bytes_used = 0;
-    hdr_ptr->hdr.bytes_left = sizeofobject + slop;
-    if (prev_hdr_ptr == NULL)	/* first pool in class? */
-      mem->small_list[pool_id] = hdr_ptr;
-    else
-      prev_hdr_ptr->hdr.next = hdr_ptr;
-  }
-
-  /* OK, allocate the object from the current pool */
-  data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */
-  data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */
-  hdr_ptr->hdr.bytes_used += sizeofobject;
-  hdr_ptr->hdr.bytes_left -= sizeofobject;
-
-  return (void *) data_ptr;
-}
-
-
-/*
- * Allocation of "large" objects.
- *
- * The external semantics of these are the same as "small" objects,
- * except that FAR pointers are used on 80x86.  However the pool
- * management heuristics are quite different.  We assume that each
- * request is large enough that it may as well be passed directly to
- * jpeg_get_large; the pool management just links everything together
- * so that we can free it all on demand.
- * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY
- * structures.  The routines that create these structures (see below)
- * deliberately bunch rows together to ensure a large request size.
- */
-
-METHODDEF(void FAR *)
-alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
-/* Allocate a "large" object */
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  large_pool_ptr hdr_ptr;
-  size_t odd_bytes;
-
-  /* Check for unsatisfiable request (do now to ensure no overflow below) */
-  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))
-    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */
-
-  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
-  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
-  if (odd_bytes > 0)
-    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
-
-  /* Always make a new pool */
-  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
-    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
-
-  hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +
-					    SIZEOF(large_pool_hdr));
-  if (hdr_ptr == NULL)
-    out_of_memory(cinfo, 4);	/* jpeg_get_large failed */
-  mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);
-
-  /* Success, initialize the new pool header and add to list */
-  hdr_ptr->hdr.next = mem->large_list[pool_id];
-  /* We maintain space counts in each pool header for statistical purposes,
-   * even though they are not needed for allocation.
-   */
-  hdr_ptr->hdr.bytes_used = sizeofobject;
-  hdr_ptr->hdr.bytes_left = 0;
-  mem->large_list[pool_id] = hdr_ptr;
-
-  return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */
-}
-
-
-/*
- * Creation of 2-D sample arrays.
- * The pointers are in near heap, the samples themselves in FAR heap.
- *
- * To minimize allocation overhead and to allow I/O of large contiguous
- * blocks, we allocate the sample rows in groups of as many rows as possible
- * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request.
- * NB: the virtual array control routines, later in this file, know about
- * this chunking of rows.  The rowsperchunk value is left in the mem manager
- * object so that it can be saved away if this sarray is the workspace for
- * a virtual array.
- */
-
-METHODDEF(JSAMPARRAY)
-alloc_sarray (j_common_ptr cinfo, int pool_id,
-	      JDIMENSION samplesperrow, JDIMENSION numrows)
-/* Allocate a 2-D sample array */
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  JSAMPARRAY result;
-  JSAMPROW workspace;
-  JDIMENSION rowsperchunk, currow, i;
-  long ltemp;
-
-  /* Calculate max # of rows allowed in one allocation chunk */
-  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
-	  ((long) samplesperrow * SIZEOF(JSAMPLE));
-  if (ltemp <= 0)
-    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
-  if (ltemp < (long) numrows)
-    rowsperchunk = (JDIMENSION) ltemp;
-  else
-    rowsperchunk = numrows;
-  mem->last_rowsperchunk = rowsperchunk;
-
-  /* Get space for row pointers (small object) */
-  result = (JSAMPARRAY) alloc_small(cinfo, pool_id,
-				    (size_t) (numrows * SIZEOF(JSAMPROW)));
-
-  /* Get the rows themselves (large objects) */
-  currow = 0;
-  while (currow < numrows) {
-    rowsperchunk = MIN(rowsperchunk, numrows - currow);
-    workspace = (JSAMPROW) alloc_large(cinfo, pool_id,
-	(size_t) ((size_t) rowsperchunk * (size_t) samplesperrow
-		  * SIZEOF(JSAMPLE)));
-    for (i = rowsperchunk; i > 0; i--) {
-      result[currow++] = workspace;
-      workspace += samplesperrow;
-    }
-  }
-
-  return result;
-}
-
-
-/*
- * Creation of 2-D coefficient-block arrays.
- * This is essentially the same as the code for sample arrays, above.
- */
-
-METHODDEF(JBLOCKARRAY)
-alloc_barray (j_common_ptr cinfo, int pool_id,
-	      JDIMENSION blocksperrow, JDIMENSION numrows)
-/* Allocate a 2-D coefficient-block array */
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  JBLOCKARRAY result;
-  JBLOCKROW workspace;
-  JDIMENSION rowsperchunk, currow, i;
-  long ltemp;
-
-  /* Calculate max # of rows allowed in one allocation chunk */
-  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
-	  ((long) blocksperrow * SIZEOF(JBLOCK));
-  if (ltemp <= 0)
-    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
-  if (ltemp < (long) numrows)
-    rowsperchunk = (JDIMENSION) ltemp;
-  else
-    rowsperchunk = numrows;
-  mem->last_rowsperchunk = rowsperchunk;
-
-  /* Get space for row pointers (small object) */
-  result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
-				     (size_t) (numrows * SIZEOF(JBLOCKROW)));
-
-  /* Get the rows themselves (large objects) */
-  currow = 0;
-  while (currow < numrows) {
-    rowsperchunk = MIN(rowsperchunk, numrows - currow);
-    workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
-	(size_t) ((size_t) rowsperchunk * (size_t) blocksperrow
-		  * SIZEOF(JBLOCK)));
-    for (i = rowsperchunk; i > 0; i--) {
-      result[currow++] = workspace;
-      workspace += blocksperrow;
-    }
-  }
-
-  return result;
-}
-
-
-/*
- * About virtual array management:
- *
- * The above "normal" array routines are only used to allocate strip buffers
- * (as wide as the image, but just a few rows high).  Full-image-sized buffers
- * are handled as "virtual" arrays.  The array is still accessed a strip at a
- * time, but the memory manager must save the whole array for repeated
- * accesses.  The intended implementation is that there is a strip buffer in
- * memory (as high as is possible given the desired memory limit), plus a
- * backing file that holds the rest of the array.
- *
- * The request_virt_array routines are told the total size of the image and
- * the maximum number of rows that will be accessed at once.  The in-memory
- * buffer must be at least as large as the maxaccess value.
- *
- * The request routines create control blocks but not the in-memory buffers.
- * That is postponed until realize_virt_arrays is called.  At that time the
- * total amount of space needed is known (approximately, anyway), so free
- * memory can be divided up fairly.
- *
- * The access_virt_array routines are responsible for making a specific strip
- * area accessible (after reading or writing the backing file, if necessary).
- * Note that the access routines are told whether the caller intends to modify
- * the accessed strip; during a read-only pass this saves having to rewrite
- * data to disk.  The access routines are also responsible for pre-zeroing
- * any newly accessed rows, if pre-zeroing was requested.
- *
- * In current usage, the access requests are usually for nonoverlapping
- * strips; that is, successive access start_row numbers differ by exactly
- * num_rows = maxaccess.  This means we can get good performance with simple
- * buffer dump/reload logic, by making the in-memory buffer be a multiple
- * of the access height; then there will never be accesses across bufferload
- * boundaries.  The code will still work with overlapping access requests,
- * but it doesn't handle bufferload overlaps very efficiently.
- */
-
-
-METHODDEF(jvirt_sarray_ptr)
-request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
-		     JDIMENSION samplesperrow, JDIMENSION numrows,
-		     JDIMENSION maxaccess)
-/* Request a virtual 2-D sample array */
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  jvirt_sarray_ptr result;
-
-  /* Only IMAGE-lifetime virtual arrays are currently supported */
-  if (pool_id != JPOOL_IMAGE)
-    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
-
-  /* get control block */
-  result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,
-					  SIZEOF(struct jvirt_sarray_control));
-
-  result->mem_buffer = NULL;	/* marks array not yet realized */
-  result->rows_in_array = numrows;
-  result->samplesperrow = samplesperrow;
-  result->maxaccess = maxaccess;
-  result->pre_zero = pre_zero;
-  result->b_s_open = FALSE;	/* no associated backing-store object */
-  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
-  mem->virt_sarray_list = result;
-
-  return result;
-}
-
-
-METHODDEF(jvirt_barray_ptr)
-request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
-		     JDIMENSION blocksperrow, JDIMENSION numrows,
-		     JDIMENSION maxaccess)
-/* Request a virtual 2-D coefficient-block array */
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  jvirt_barray_ptr result;
-
-  /* Only IMAGE-lifetime virtual arrays are currently supported */
-  if (pool_id != JPOOL_IMAGE)
-    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
-
-  /* get control block */
-  result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,
-					  SIZEOF(struct jvirt_barray_control));
-
-  result->mem_buffer = NULL;	/* marks array not yet realized */
-  result->rows_in_array = numrows;
-  result->blocksperrow = blocksperrow;
-  result->maxaccess = maxaccess;
-  result->pre_zero = pre_zero;
-  result->b_s_open = FALSE;	/* no associated backing-store object */
-  result->next = mem->virt_barray_list; /* add to list of virtual arrays */
-  mem->virt_barray_list = result;
-
-  return result;
-}
-
-
-METHODDEF(void)
-realize_virt_arrays (j_common_ptr cinfo)
-/* Allocate the in-memory buffers for any unrealized virtual arrays */
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  long space_per_minheight, maximum_space, avail_mem;
-  long minheights, max_minheights;
-  jvirt_sarray_ptr sptr;
-  jvirt_barray_ptr bptr;
-
-  /* Compute the minimum space needed (maxaccess rows in each buffer)
-   * and the maximum space needed (full image height in each buffer).
-   * These may be of use to the system-dependent jpeg_mem_available routine.
-   */
-  space_per_minheight = 0;
-  maximum_space = 0;
-  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
-    if (sptr->mem_buffer == NULL) { /* if not realized yet */
-      space_per_minheight += (long) sptr->maxaccess *
-			     (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
-      maximum_space += (long) sptr->rows_in_array *
-		       (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
-    }
-  }
-  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
-    if (bptr->mem_buffer == NULL) { /* if not realized yet */
-      space_per_minheight += (long) bptr->maxaccess *
-			     (long) bptr->blocksperrow * SIZEOF(JBLOCK);
-      maximum_space += (long) bptr->rows_in_array *
-		       (long) bptr->blocksperrow * SIZEOF(JBLOCK);
-    }
-  }
-
-  if (space_per_minheight <= 0)
-    return;			/* no unrealized arrays, no work */
-
-  /* Determine amount of memory to actually use; this is system-dependent. */
-  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
-				 mem->total_space_allocated);
-
-  /* If the maximum space needed is available, make all the buffers full
-   * height; otherwise parcel it out with the same number of minheights
-   * in each buffer.
-   */
-  if (avail_mem >= maximum_space)
-    max_minheights = 1000000000L;
-  else {
-    max_minheights = avail_mem / space_per_minheight;
-    /* If there doesn't seem to be enough space, try to get the minimum
-     * anyway.  This allows a "stub" implementation of jpeg_mem_available().
-     */
-    if (max_minheights <= 0)
-      max_minheights = 1;
-  }
-
-  /* Allocate the in-memory buffers and initialize backing store as needed. */
-
-  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
-    if (sptr->mem_buffer == NULL) { /* if not realized yet */
-      minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;
-      if (minheights <= max_minheights) {
-	/* This buffer fits in memory */
-	sptr->rows_in_mem = sptr->rows_in_array;
-      } else {
-	/* It doesn't fit in memory, create backing store. */
-	sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);
-	jpeg_open_backing_store(cinfo, & sptr->b_s_info,
-				(long) sptr->rows_in_array *
-				(long) sptr->samplesperrow *
-				(long) SIZEOF(JSAMPLE));
-	sptr->b_s_open = TRUE;
-      }
-      sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,
-				      sptr->samplesperrow, sptr->rows_in_mem);
-      sptr->rowsperchunk = mem->last_rowsperchunk;
-      sptr->cur_start_row = 0;
-      sptr->first_undef_row = 0;
-      sptr->dirty = FALSE;
-    }
-  }
-
-  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
-    if (bptr->mem_buffer == NULL) { /* if not realized yet */
-      minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;
-      if (minheights <= max_minheights) {
-	/* This buffer fits in memory */
-	bptr->rows_in_mem = bptr->rows_in_array;
-      } else {
-	/* It doesn't fit in memory, create backing store. */
-	bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);
-	jpeg_open_backing_store(cinfo, & bptr->b_s_info,
-				(long) bptr->rows_in_array *
-				(long) bptr->blocksperrow *
-				(long) SIZEOF(JBLOCK));
-	bptr->b_s_open = TRUE;
-      }
-      bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,
-				      bptr->blocksperrow, bptr->rows_in_mem);
-      bptr->rowsperchunk = mem->last_rowsperchunk;
-      bptr->cur_start_row = 0;
-      bptr->first_undef_row = 0;
-      bptr->dirty = FALSE;
-    }
-  }
-}
-
-
-LOCAL(void)
-do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
-/* Do backing store read or write of a virtual sample array */
-{
-  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
-
-  bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);
-  file_offset = ptr->cur_start_row * bytesperrow;
-  /* Loop to read or write each allocation chunk in mem_buffer */
-  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
-    /* One chunk, but check for short chunk at end of buffer */
-    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
-    /* Transfer no more than is currently defined */
-    thisrow = (long) ptr->cur_start_row + i;
-    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
-    /* Transfer no more than fits in file */
-    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
-    if (rows <= 0)		/* this chunk might be past end of file! */
-      break;
-    byte_count = rows * bytesperrow;
-    if (writing)
-      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
-					    (void FAR *) ptr->mem_buffer[i],
-					    file_offset, byte_count);
-    else
-      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
-					   (void FAR *) ptr->mem_buffer[i],
-					   file_offset, byte_count);
-    file_offset += byte_count;
-  }
-}
-
-
-LOCAL(void)
-do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
-/* Do backing store read or write of a virtual coefficient-block array */
-{
-  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
-
-  bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);
-  file_offset = ptr->cur_start_row * bytesperrow;
-  /* Loop to read or write each allocation chunk in mem_buffer */
-  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
-    /* One chunk, but check for short chunk at end of buffer */
-    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
-    /* Transfer no more than is currently defined */
-    thisrow = (long) ptr->cur_start_row + i;
-    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
-    /* Transfer no more than fits in file */
-    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
-    if (rows <= 0)		/* this chunk might be past end of file! */
-      break;
-    byte_count = rows * bytesperrow;
-    if (writing)
-      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
-					    (void FAR *) ptr->mem_buffer[i],
-					    file_offset, byte_count);
-    else
-      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
-					   (void FAR *) ptr->mem_buffer[i],
-					   file_offset, byte_count);
-    file_offset += byte_count;
-  }
-}
-
-
-METHODDEF(JSAMPARRAY)
-access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
-		    JDIMENSION start_row, JDIMENSION num_rows,
-		    boolean writable)
-/* Access the part of a virtual sample array starting at start_row */
-/* and extending for num_rows rows.  writable is true if  */
-/* caller intends to modify the accessed area. */
-{
-  JDIMENSION end_row = start_row + num_rows;
-  JDIMENSION undef_row;
-
-  /* debugging check */
-  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
-      ptr->mem_buffer == NULL)
-    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
-
-  /* Make the desired part of the virtual array accessible */
-  if (start_row < ptr->cur_start_row ||
-      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
-    if (! ptr->b_s_open)
-      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
-    /* Flush old buffer contents if necessary */
-    if (ptr->dirty) {
-      do_sarray_io(cinfo, ptr, TRUE);
-      ptr->dirty = FALSE;
-    }
-    /* Decide what part of virtual array to access.
-     * Algorithm: if target address > current window, assume forward scan,
-     * load starting at target address.  If target address < current window,
-     * assume backward scan, load so that target area is top of window.
-     * Note that when switching from forward write to forward read, will have
-     * start_row = 0, so the limiting case applies and we load from 0 anyway.
-     */
-    if (start_row > ptr->cur_start_row) {
-      ptr->cur_start_row = start_row;
-    } else {
-      /* use long arithmetic here to avoid overflow & unsigned problems */
-      long ltemp;
-
-      ltemp = (long) end_row - (long) ptr->rows_in_mem;
-      if (ltemp < 0)
-	ltemp = 0;		/* don't fall off front end of file */
-      ptr->cur_start_row = (JDIMENSION) ltemp;
-    }
-    /* Read in the selected part of the array.
-     * During the initial write pass, we will do no actual read
-     * because the selected part is all undefined.
-     */
-    do_sarray_io(cinfo, ptr, FALSE);
-  }
-  /* Ensure the accessed part of the array is defined; prezero if needed.
-   * To improve locality of access, we only prezero the part of the array
-   * that the caller is about to access, not the entire in-memory array.
-   */
-  if (ptr->first_undef_row < end_row) {
-    if (ptr->first_undef_row < start_row) {
-      if (writable)		/* writer skipped over a section of array */
-	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
-      undef_row = start_row;	/* but reader is allowed to read ahead */
-    } else {
-      undef_row = ptr->first_undef_row;
-    }
-    if (writable)
-      ptr->first_undef_row = end_row;
-    if (ptr->pre_zero) {
-      size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);
-      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
-      end_row -= ptr->cur_start_row;
-      while (undef_row < end_row) {
-	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
-	undef_row++;
-      }
-    } else {
-      if (! writable)		/* reader looking at undefined data */
-	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
-    }
-  }
-  /* Flag the buffer dirty if caller will write in it */
-  if (writable)
-    ptr->dirty = TRUE;
-  /* Return address of proper part of the buffer */
-  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
-}
-
-
-METHODDEF(JBLOCKARRAY)
-access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr,
-		    JDIMENSION start_row, JDIMENSION num_rows,
-		    boolean writable)
-/* Access the part of a virtual block array starting at start_row */
-/* and extending for num_rows rows.  writable is true if  */
-/* caller intends to modify the accessed area. */
-{
-  JDIMENSION end_row = start_row + num_rows;
-  JDIMENSION undef_row;
-
-  /* debugging check */
-  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
-      ptr->mem_buffer == NULL)
-    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
-
-  /* Make the desired part of the virtual array accessible */
-  if (start_row < ptr->cur_start_row ||
-      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
-    if (! ptr->b_s_open)
-      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
-    /* Flush old buffer contents if necessary */
-    if (ptr->dirty) {
-      do_barray_io(cinfo, ptr, TRUE);
-      ptr->dirty = FALSE;
-    }
-    /* Decide what part of virtual array to access.
-     * Algorithm: if target address > current window, assume forward scan,
-     * load starting at target address.  If target address < current window,
-     * assume backward scan, load so that target area is top of window.
-     * Note that when switching from forward write to forward read, will have
-     * start_row = 0, so the limiting case applies and we load from 0 anyway.
-     */
-    if (start_row > ptr->cur_start_row) {
-      ptr->cur_start_row = start_row;
-    } else {
-      /* use long arithmetic here to avoid overflow & unsigned problems */
-      long ltemp;
-
-      ltemp = (long) end_row - (long) ptr->rows_in_mem;
-      if (ltemp < 0)
-	ltemp = 0;		/* don't fall off front end of file */
-      ptr->cur_start_row = (JDIMENSION) ltemp;
-    }
-    /* Read in the selected part of the array.
-     * During the initial write pass, we will do no actual read
-     * because the selected part is all undefined.
-     */
-    do_barray_io(cinfo, ptr, FALSE);
-  }
-  /* Ensure the accessed part of the array is defined; prezero if needed.
-   * To improve locality of access, we only prezero the part of the array
-   * that the caller is about to access, not the entire in-memory array.
-   */
-  if (ptr->first_undef_row < end_row) {
-    if (ptr->first_undef_row < start_row) {
-      if (writable)		/* writer skipped over a section of array */
-	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
-      undef_row = start_row;	/* but reader is allowed to read ahead */
-    } else {
-      undef_row = ptr->first_undef_row;
-    }
-    if (writable)
-      ptr->first_undef_row = end_row;
-    if (ptr->pre_zero) {
-      size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK);
-      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
-      end_row -= ptr->cur_start_row;
-      while (undef_row < end_row) {
-	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
-	undef_row++;
-      }
-    } else {
-      if (! writable)		/* reader looking at undefined data */
-	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
-    }
-  }
-  /* Flag the buffer dirty if caller will write in it */
-  if (writable)
-    ptr->dirty = TRUE;
-  /* Return address of proper part of the buffer */
-  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
-}
-
-
-/*
- * Release all objects belonging to a specified pool.
- */
-
-METHODDEF(void)
-free_pool (j_common_ptr cinfo, int pool_id)
-{
-  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
-  small_pool_ptr shdr_ptr;
-  large_pool_ptr lhdr_ptr;
-  size_t space_freed;
-
-  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
-    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
-
-#ifdef MEM_STATS
-  if (cinfo->err->trace_level > 1)
-    print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */
-#endif
-
-  /* If freeing IMAGE pool, close any virtual arrays first */
-  if (pool_id == JPOOL_IMAGE) {
-    jvirt_sarray_ptr sptr;
-    jvirt_barray_ptr bptr;
-
-    for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
-      if (sptr->b_s_open) {	/* there may be no backing store */
-	sptr->b_s_open = FALSE;	/* prevent recursive close if error */
-	(*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info);
-      }
-    }
-    mem->virt_sarray_list = NULL;
-    for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
-      if (bptr->b_s_open) {	/* there may be no backing store */
-	bptr->b_s_open = FALSE;	/* prevent recursive close if error */
-	(*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info);
-      }
-    }
-    mem->virt_barray_list = NULL;
-  }
-
-  /* Release large objects */
-  lhdr_ptr = mem->large_list[pool_id];
-  mem->large_list[pool_id] = NULL;
-
-  while (lhdr_ptr != NULL) {
-    large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next;
-    space_freed = lhdr_ptr->hdr.bytes_used +
-		  lhdr_ptr->hdr.bytes_left +
-		  SIZEOF(large_pool_hdr);
-    jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed);
-    mem->total_space_allocated -= space_freed;
-    lhdr_ptr = next_lhdr_ptr;
-  }
-
-  /* Release small objects */
-  shdr_ptr = mem->small_list[pool_id];
-  mem->small_list[pool_id] = NULL;
-
-  while (shdr_ptr != NULL) {
-    small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next;
-    space_freed = shdr_ptr->hdr.bytes_used +
-		  shdr_ptr->hdr.bytes_left +
-		  SIZEOF(small_pool_hdr);
-    jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed);
-    mem->total_space_allocated -= space_freed;
-    shdr_ptr = next_shdr_ptr;
-  }
-}
-
-
-/*
- * Close up shop entirely.
- * Note that this cannot be called unless cinfo->mem is non-NULL.
- */
-
-METHODDEF(void)
-self_destruct (j_common_ptr cinfo)
-{
-  int pool;
-
-  /* Close all backing store, release all memory.
-   * Releasing pools in reverse order might help avoid fragmentation
-   * with some (brain-damaged) malloc libraries.
-   */
-  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
-    free_pool(cinfo, pool);
-  }
-
-  /* Release the memory manager control block too. */
-  jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));
-  cinfo->mem = NULL;		/* ensures I will be called only once */
-
-  jpeg_mem_term(cinfo);		/* system-dependent cleanup */
-}
-
-
-/*
- * Memory manager initialization.
- * When this is called, only the error manager pointer is valid in cinfo!
- */
-
-GLOBAL(void)
-jinit_memory_mgr (j_common_ptr cinfo)
-{
-  my_mem_ptr mem;
-  long max_to_use;
-  int pool;
-  size_t test_mac;
-
-  cinfo->mem = NULL;		/* for safety if init fails */
-
-  /* Check for configuration errors.
-   * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably
-   * doesn't reflect any real hardware alignment requirement.
-   * The test is a little tricky: for X>0, X and X-1 have no one-bits
-   * in common if and only if X is a power of 2, ie has only one one-bit.
-   * Some compilers may give an "unreachable code" warning here; ignore it.
-   */
-  if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0)
-    ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);
-  /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be
-   * a multiple of SIZEOF(ALIGN_TYPE).
-   * Again, an "unreachable code" warning may be ignored here.
-   * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.
-   */
-  test_mac = (size_t) MAX_ALLOC_CHUNK;
-  if ((long) test_mac != MAX_ALLOC_CHUNK ||
-      (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0)
-    ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
-
-  max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */
-
-  /* Attempt to allocate memory manager's control block */
-  mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr));
-
-  if (mem == NULL) {
-    jpeg_mem_term(cinfo);	/* system-dependent cleanup */
-    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);
-  }
-
-  /* OK, fill in the method pointers */
-  mem->pub.alloc_small = alloc_small;
-  mem->pub.alloc_large = alloc_large;
-  mem->pub.alloc_sarray = alloc_sarray;
-  mem->pub.alloc_barray = alloc_barray;
-  mem->pub.request_virt_sarray = request_virt_sarray;
-  mem->pub.request_virt_barray = request_virt_barray;
-  mem->pub.realize_virt_arrays = realize_virt_arrays;
-  mem->pub.access_virt_sarray = access_virt_sarray;
-  mem->pub.access_virt_barray = access_virt_barray;
-  mem->pub.free_pool = free_pool;
-  mem->pub.self_destruct = self_destruct;
-
-  /* Make MAX_ALLOC_CHUNK accessible to other modules */
-  mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK;
-
-  /* Initialize working state */
-  mem->pub.max_memory_to_use = max_to_use;
-
-  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
-    mem->small_list[pool] = NULL;
-    mem->large_list[pool] = NULL;
-  }
-  mem->virt_sarray_list = NULL;
-  mem->virt_barray_list = NULL;
-
-  mem->total_space_allocated = SIZEOF(my_memory_mgr);
-
-  /* Declare ourselves open for business */
-  cinfo->mem = & mem->pub;
-
-  /* Check for an environment variable JPEGMEM; if found, override the
-   * default max_memory setting from jpeg_mem_init.  Note that the
-   * surrounding application may again override this value.
-   * If your system doesn't support getenv(), define NO_GETENV to disable
-   * this feature.
-   */
-#ifndef NO_GETENV
-  { char * memenv;
-
-    if ((memenv = getenv("JPEGMEM")) != NULL) {
-      char ch = 'x';
-
-      if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {
-	if (ch == 'm' || ch == 'M')
-	  max_to_use *= 1000L;
-	mem->pub.max_memory_to_use = max_to_use * 1000L;
-      }
-    }
-  }
-#endif
-
-}
+/*

+ * jmemmgr.c

+ *

+ * Copyright (C) 1991-1997, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains the JPEG system-independent memory management

+ * routines.  This code is usable across a wide variety of machines; most

+ * of the system dependencies have been isolated in a separate file.

+ * The major functions provided here are:

+ *   * pool-based allocation and freeing of memory;

+ *   * policy decisions about how to divide available memory among the

+ *     virtual arrays;

+ *   * control logic for swapping virtual arrays between main memory and

+ *     backing storage.

+ * The separate system-dependent file provides the actual backing-storage

+ * access code, and it contains the policy decision about how much total

+ * main memory to use.

+ * This file is system-dependent in the sense that some of its functions

+ * are unnecessary in some systems.  For example, if there is enough virtual

+ * memory so that backing storage will never be used, much of the virtual

+ * array control logic could be removed.  (Of course, if you have that much

+ * memory then you shouldn't care about a little bit of unused code...)

+ */

+

+#define JPEG_INTERNALS

+#define AM_MEMORY_MANAGER	/* we define jvirt_Xarray_control structs */

+#include "jinclude.h"

+#include "jpeglib.h"

+#include "jmemsys.h"		/* import the system-dependent declarations */

+

+#ifndef NO_GETENV

+#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare getenv() */

+extern char * getenv JPP((const char * name));

+#endif

+#endif

+

+

+/*

+ * Some important notes:

+ *   The allocation routines provided here must never return NULL.

+ *   They should exit to error_exit if unsuccessful.

+ *

+ *   It's not a good idea to try to merge the sarray and barray routines,

+ *   even though they are textually almost the same, because samples are

+ *   usually stored as bytes while coefficients are shorts or ints.  Thus,

+ *   in machines where byte pointers have a different representation from

+ *   word pointers, the resulting machine code could not be the same.

+ */

+

+

+/*

+ * Many machines require storage alignment: longs must start on 4-byte

+ * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc()

+ * always returns pointers that are multiples of the worst-case alignment

+ * requirement, and we had better do so too.

+ * There isn't any really portable way to determine the worst-case alignment

+ * requirement.  This module assumes that the alignment requirement is

+ * multiples of sizeof(ALIGN_TYPE).

+ * By default, we define ALIGN_TYPE as double.  This is necessary on some

+ * workstations (where doubles really do need 8-byte alignment) and will work

+ * fine on nearly everything.  If your machine has lesser alignment needs,

+ * you can save a few bytes by making ALIGN_TYPE smaller.

+ * The only place I know of where this will NOT work is certain Macintosh

+ * 680x0 compilers that define double as a 10-byte IEEE extended float.

+ * Doing 10-byte alignment is counterproductive because longwords won't be

+ * aligned well.  Put "#define ALIGN_TYPE long" in jconfig.h if you have

+ * such a compiler.

+ */

+

+#ifndef ALIGN_TYPE		/* so can override from jconfig.h */

+#define ALIGN_TYPE  double

+#endif

+

+

+/*

+ * We allocate objects from "pools", where each pool is gotten with a single

+ * request to jpeg_get_small() or jpeg_get_large().  There is no per-object

+ * overhead within a pool, except for alignment padding.  Each pool has a

+ * header with a link to the next pool of the same class.

+ * Small and large pool headers are identical except that the latter's

+ * link pointer must be FAR on 80x86 machines.

+ * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE

+ * field.  This forces the compiler to make SIZEOF(small_pool_hdr) a multiple

+ * of the alignment requirement of ALIGN_TYPE.

+ */

+

+typedef union small_pool_struct * small_pool_ptr;

+

+typedef union small_pool_struct {

+  struct {

+    small_pool_ptr next;	/* next in list of pools */

+    size_t bytes_used;		/* how many bytes already used within pool */

+    size_t bytes_left;		/* bytes still available in this pool */

+  } hdr;

+  ALIGN_TYPE dummy;		/* included in union to ensure alignment */

+} small_pool_hdr;

+

+typedef union large_pool_struct FAR * large_pool_ptr;

+

+typedef union large_pool_struct {

+  struct {

+    large_pool_ptr next;	/* next in list of pools */

+    size_t bytes_used;		/* how many bytes already used within pool */

+    size_t bytes_left;		/* bytes still available in this pool */

+  } hdr;

+  ALIGN_TYPE dummy;		/* included in union to ensure alignment */

+} large_pool_hdr;

+

+

+/*

+ * Here is the full definition of a memory manager object.

+ */

+

+typedef struct {

+  struct jpeg_memory_mgr pub;	/* public fields */

+

+  /* Each pool identifier (lifetime class) names a linked list of pools. */

+  small_pool_ptr small_list[JPOOL_NUMPOOLS];

+  large_pool_ptr large_list[JPOOL_NUMPOOLS];

+

+  /* Since we only have one lifetime class of virtual arrays, only one

+   * linked list is necessary (for each datatype).  Note that the virtual

+   * array control blocks being linked together are actually stored somewhere

+   * in the small-pool list.

+   */

+  jvirt_sarray_ptr virt_sarray_list;

+  jvirt_barray_ptr virt_barray_list;

+

+  /* This counts total space obtained from jpeg_get_small/large */

+  long total_space_allocated;

+

+  /* alloc_sarray and alloc_barray set this value for use by virtual

+   * array routines.

+   */

+  JDIMENSION last_rowsperchunk;	/* from most recent alloc_sarray/barray */

+} my_memory_mgr;

+

+typedef my_memory_mgr * my_mem_ptr;

+

+

+/*

+ * The control blocks for virtual arrays.

+ * Note that these blocks are allocated in the "small" pool area.

+ * System-dependent info for the associated backing store (if any) is hidden

+ * inside the backing_store_info struct.

+ */

+

+struct jvirt_sarray_control {

+  JSAMPARRAY mem_buffer;	/* => the in-memory buffer */

+  JDIMENSION rows_in_array;	/* total virtual array height */

+  JDIMENSION samplesperrow;	/* width of array (and of memory buffer) */

+  JDIMENSION maxaccess;		/* max rows accessed by access_virt_sarray */

+  JDIMENSION rows_in_mem;	/* height of memory buffer */

+  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */

+  JDIMENSION cur_start_row;	/* first logical row # in the buffer */

+  JDIMENSION first_undef_row;	/* row # of first uninitialized row */

+  boolean pre_zero;		/* pre-zero mode requested? */

+  boolean dirty;		/* do current buffer contents need written? */

+  boolean b_s_open;		/* is backing-store data valid? */

+  jvirt_sarray_ptr next;	/* link to next virtual sarray control block */

+  backing_store_info b_s_info;	/* System-dependent control info */

+};

+

+struct jvirt_barray_control {

+  JBLOCKARRAY mem_buffer;	/* => the in-memory buffer */

+  JDIMENSION rows_in_array;	/* total virtual array height */

+  JDIMENSION blocksperrow;	/* width of array (and of memory buffer) */

+  JDIMENSION maxaccess;		/* max rows accessed by access_virt_barray */

+  JDIMENSION rows_in_mem;	/* height of memory buffer */

+  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */

+  JDIMENSION cur_start_row;	/* first logical row # in the buffer */

+  JDIMENSION first_undef_row;	/* row # of first uninitialized row */

+  boolean pre_zero;		/* pre-zero mode requested? */

+  boolean dirty;		/* do current buffer contents need written? */

+  boolean b_s_open;		/* is backing-store data valid? */

+  jvirt_barray_ptr next;	/* link to next virtual barray control block */

+  backing_store_info b_s_info;	/* System-dependent control info */

+};

+

+

+#ifdef MEM_STATS		/* optional extra stuff for statistics */

+

+LOCAL(void)

+print_mem_stats (j_common_ptr cinfo, int pool_id)

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  small_pool_ptr shdr_ptr;

+  large_pool_ptr lhdr_ptr;

+

+  /* Since this is only a debugging stub, we can cheat a little by using

+   * fprintf directly rather than going through the trace message code.

+   * This is helpful because message parm array can't handle longs.

+   */

+  fprintf(stderr, "Freeing pool %d, total space = %ld\n",

+	  pool_id, mem->total_space_allocated);

+

+  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;

+       lhdr_ptr = lhdr_ptr->hdr.next) {

+    fprintf(stderr, "  Large chunk used %ld\n",

+	    (long) lhdr_ptr->hdr.bytes_used);

+  }

+

+  for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;

+       shdr_ptr = shdr_ptr->hdr.next) {

+    fprintf(stderr, "  Small chunk used %ld free %ld\n",

+	    (long) shdr_ptr->hdr.bytes_used,

+	    (long) shdr_ptr->hdr.bytes_left);

+  }

+}

+

+#endif /* MEM_STATS */

+

+

+LOCAL(void)

+out_of_memory (j_common_ptr cinfo, int which)

+/* Report an out-of-memory error and stop execution */

+/* If we compiled MEM_STATS support, report alloc requests before dying */

+{

+#ifdef MEM_STATS

+  cinfo->err->trace_level = 2;	/* force self_destruct to report stats */

+#endif

+  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);

+}

+

+

+/*

+ * Allocation of "small" objects.

+ *

+ * For these, we use pooled storage.  When a new pool must be created,

+ * we try to get enough space for the current request plus a "slop" factor,

+ * where the slop will be the amount of leftover space in the new pool.

+ * The speed vs. space tradeoff is largely determined by the slop values.

+ * A different slop value is provided for each pool class (lifetime),

+ * and we also distinguish the first pool of a class from later ones.

+ * NOTE: the values given work fairly well on both 16- and 32-bit-int

+ * machines, but may be too small if longs are 64 bits or more.

+ */

+

+static const size_t first_pool_slop[JPOOL_NUMPOOLS] = 

+{

+	1600,			/* first PERMANENT pool */

+	16000			/* first IMAGE pool */

+};

+

+static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = 

+{

+	0,			/* additional PERMANENT pools */

+	5000			/* additional IMAGE pools */

+};

+

+#define MIN_SLOP  50		/* greater than 0 to avoid futile looping */

+

+

+METHODDEF(void *)

+alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)

+/* Allocate a "small" object */

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  small_pool_ptr hdr_ptr, prev_hdr_ptr;

+  char * data_ptr;

+  size_t odd_bytes, min_request, slop;

+

+  /* Check for unsatisfiable request (do now to ensure no overflow below) */

+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))

+    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */

+

+  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */

+  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);

+  if (odd_bytes > 0)

+    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;

+

+  /* See if space is available in any existing pool */

+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)

+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

+  prev_hdr_ptr = NULL;

+  hdr_ptr = mem->small_list[pool_id];

+  while (hdr_ptr != NULL) {

+    if (hdr_ptr->hdr.bytes_left >= sizeofobject)

+      break;			/* found pool with enough space */

+    prev_hdr_ptr = hdr_ptr;

+    hdr_ptr = hdr_ptr->hdr.next;

+  }

+

+  /* Time to make a new pool? */

+  if (hdr_ptr == NULL) {

+    /* min_request is what we need now, slop is what will be leftover */

+    min_request = sizeofobject + SIZEOF(small_pool_hdr);

+    if (prev_hdr_ptr == NULL)	/* first pool in class? */

+      slop = first_pool_slop[pool_id];

+    else

+      slop = extra_pool_slop[pool_id];

+    /* Don't ask for more than MAX_ALLOC_CHUNK */

+    if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))

+      slop = (size_t) (MAX_ALLOC_CHUNK-min_request);

+    /* Try to get space, if fail reduce slop and try again */

+    for (;;) {

+      hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);

+      if (hdr_ptr != NULL)

+	break;

+      slop /= 2;

+      if (slop < MIN_SLOP)	/* give up when it gets real small */

+	out_of_memory(cinfo, 2); /* jpeg_get_small failed */

+    }

+    mem->total_space_allocated += min_request + slop;

+    /* Success, initialize the new pool header and add to end of list */

+    hdr_ptr->hdr.next = NULL;

+    hdr_ptr->hdr.bytes_used = 0;

+    hdr_ptr->hdr.bytes_left = sizeofobject + slop;

+    if (prev_hdr_ptr == NULL)	/* first pool in class? */

+      mem->small_list[pool_id] = hdr_ptr;

+    else

+      prev_hdr_ptr->hdr.next = hdr_ptr;

+  }

+

+  /* OK, allocate the object from the current pool */

+  data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */

+  data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */

+  hdr_ptr->hdr.bytes_used += sizeofobject;

+  hdr_ptr->hdr.bytes_left -= sizeofobject;

+

+  return (void *) data_ptr;

+}

+

+

+/*

+ * Allocation of "large" objects.

+ *

+ * The external semantics of these are the same as "small" objects,

+ * except that FAR pointers are used on 80x86.  However the pool

+ * management heuristics are quite different.  We assume that each

+ * request is large enough that it may as well be passed directly to

+ * jpeg_get_large; the pool management just links everything together

+ * so that we can free it all on demand.

+ * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY

+ * structures.  The routines that create these structures (see below)

+ * deliberately bunch rows together to ensure a large request size.

+ */

+

+METHODDEF(void FAR *)

+alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)

+/* Allocate a "large" object */

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  large_pool_ptr hdr_ptr;

+  size_t odd_bytes;

+

+  /* Check for unsatisfiable request (do now to ensure no overflow below) */

+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))

+    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */

+

+  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */

+  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);

+  if (odd_bytes > 0)

+    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;

+

+  /* Always make a new pool */

+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)

+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

+

+  hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +

+					    SIZEOF(large_pool_hdr));

+  if (hdr_ptr == NULL)

+    out_of_memory(cinfo, 4);	/* jpeg_get_large failed */

+  mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);

+

+  /* Success, initialize the new pool header and add to list */

+  hdr_ptr->hdr.next = mem->large_list[pool_id];

+  /* We maintain space counts in each pool header for statistical purposes,

+   * even though they are not needed for allocation.

+   */

+  hdr_ptr->hdr.bytes_used = sizeofobject;

+  hdr_ptr->hdr.bytes_left = 0;

+  mem->large_list[pool_id] = hdr_ptr;

+

+  return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */

+}

+

+

+/*

+ * Creation of 2-D sample arrays.

+ * The pointers are in near heap, the samples themselves in FAR heap.

+ *

+ * To minimize allocation overhead and to allow I/O of large contiguous

+ * blocks, we allocate the sample rows in groups of as many rows as possible

+ * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request.

+ * NB: the virtual array control routines, later in this file, know about

+ * this chunking of rows.  The rowsperchunk value is left in the mem manager

+ * object so that it can be saved away if this sarray is the workspace for

+ * a virtual array.

+ */

+

+METHODDEF(JSAMPARRAY)

+alloc_sarray (j_common_ptr cinfo, int pool_id,

+	      JDIMENSION samplesperrow, JDIMENSION numrows)

+/* Allocate a 2-D sample array */

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  JSAMPARRAY result;

+  JSAMPROW workspace;

+  JDIMENSION rowsperchunk, currow, i;

+  long ltemp;

+

+  /* Calculate max # of rows allowed in one allocation chunk */

+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /

+	  ((long) samplesperrow * SIZEOF(JSAMPLE));

+  if (ltemp <= 0)

+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);

+  if (ltemp < (long) numrows)

+    rowsperchunk = (JDIMENSION) ltemp;

+  else

+    rowsperchunk = numrows;

+  mem->last_rowsperchunk = rowsperchunk;

+

+  /* Get space for row pointers (small object) */

+  result = (JSAMPARRAY) alloc_small(cinfo, pool_id,

+				    (size_t) (numrows * SIZEOF(JSAMPROW)));

+

+  /* Get the rows themselves (large objects) */

+  currow = 0;

+  while (currow < numrows) {

+    rowsperchunk = MIN(rowsperchunk, numrows - currow);

+    workspace = (JSAMPROW) alloc_large(cinfo, pool_id,

+	(size_t) ((size_t) rowsperchunk * (size_t) samplesperrow

+		  * SIZEOF(JSAMPLE)));

+    for (i = rowsperchunk; i > 0; i--) {

+      result[currow++] = workspace;

+      workspace += samplesperrow;

+    }

+  }

+

+  return result;

+}

+

+

+/*

+ * Creation of 2-D coefficient-block arrays.

+ * This is essentially the same as the code for sample arrays, above.

+ */

+

+METHODDEF(JBLOCKARRAY)

+alloc_barray (j_common_ptr cinfo, int pool_id,

+	      JDIMENSION blocksperrow, JDIMENSION numrows)

+/* Allocate a 2-D coefficient-block array */

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  JBLOCKARRAY result;

+  JBLOCKROW workspace;

+  JDIMENSION rowsperchunk, currow, i;

+  long ltemp;

+

+  /* Calculate max # of rows allowed in one allocation chunk */

+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /

+	  ((long) blocksperrow * SIZEOF(JBLOCK));

+  if (ltemp <= 0)

+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);

+  if (ltemp < (long) numrows)

+    rowsperchunk = (JDIMENSION) ltemp;

+  else

+    rowsperchunk = numrows;

+  mem->last_rowsperchunk = rowsperchunk;

+

+  /* Get space for row pointers (small object) */

+  result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,

+				     (size_t) (numrows * SIZEOF(JBLOCKROW)));

+

+  /* Get the rows themselves (large objects) */

+  currow = 0;

+  while (currow < numrows) {

+    rowsperchunk = MIN(rowsperchunk, numrows - currow);

+    workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,

+	(size_t) ((size_t) rowsperchunk * (size_t) blocksperrow

+		  * SIZEOF(JBLOCK)));

+    for (i = rowsperchunk; i > 0; i--) {

+      result[currow++] = workspace;

+      workspace += blocksperrow;

+    }

+  }

+

+  return result;

+}

+

+

+/*

+ * About virtual array management:

+ *

+ * The above "normal" array routines are only used to allocate strip buffers

+ * (as wide as the image, but just a few rows high).  Full-image-sized buffers

+ * are handled as "virtual" arrays.  The array is still accessed a strip at a

+ * time, but the memory manager must save the whole array for repeated

+ * accesses.  The intended implementation is that there is a strip buffer in

+ * memory (as high as is possible given the desired memory limit), plus a

+ * backing file that holds the rest of the array.

+ *

+ * The request_virt_array routines are told the total size of the image and

+ * the maximum number of rows that will be accessed at once.  The in-memory

+ * buffer must be at least as large as the maxaccess value.

+ *

+ * The request routines create control blocks but not the in-memory buffers.

+ * That is postponed until realize_virt_arrays is called.  At that time the

+ * total amount of space needed is known (approximately, anyway), so free

+ * memory can be divided up fairly.

+ *

+ * The access_virt_array routines are responsible for making a specific strip

+ * area accessible (after reading or writing the backing file, if necessary).

+ * Note that the access routines are told whether the caller intends to modify

+ * the accessed strip; during a read-only pass this saves having to rewrite

+ * data to disk.  The access routines are also responsible for pre-zeroing

+ * any newly accessed rows, if pre-zeroing was requested.

+ *

+ * In current usage, the access requests are usually for nonoverlapping

+ * strips; that is, successive access start_row numbers differ by exactly

+ * num_rows = maxaccess.  This means we can get good performance with simple

+ * buffer dump/reload logic, by making the in-memory buffer be a multiple

+ * of the access height; then there will never be accesses across bufferload

+ * boundaries.  The code will still work with overlapping access requests,

+ * but it doesn't handle bufferload overlaps very efficiently.

+ */

+

+

+METHODDEF(jvirt_sarray_ptr)

+request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero,

+		     JDIMENSION samplesperrow, JDIMENSION numrows,

+		     JDIMENSION maxaccess)

+/* Request a virtual 2-D sample array */

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  jvirt_sarray_ptr result;

+

+  /* Only IMAGE-lifetime virtual arrays are currently supported */

+  if (pool_id != JPOOL_IMAGE)

+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

+

+  /* get control block */

+  result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,

+					  SIZEOF(struct jvirt_sarray_control));

+

+  result->mem_buffer = NULL;	/* marks array not yet realized */

+  result->rows_in_array = numrows;

+  result->samplesperrow = samplesperrow;

+  result->maxaccess = maxaccess;

+  result->pre_zero = pre_zero;

+  result->b_s_open = FALSE;	/* no associated backing-store object */

+  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */

+  mem->virt_sarray_list = result;

+

+  return result;

+}

+

+

+METHODDEF(jvirt_barray_ptr)

+request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero,

+		     JDIMENSION blocksperrow, JDIMENSION numrows,

+		     JDIMENSION maxaccess)

+/* Request a virtual 2-D coefficient-block array */

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  jvirt_barray_ptr result;

+

+  /* Only IMAGE-lifetime virtual arrays are currently supported */

+  if (pool_id != JPOOL_IMAGE)

+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

+

+  /* get control block */

+  result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,

+					  SIZEOF(struct jvirt_barray_control));

+

+  result->mem_buffer = NULL;	/* marks array not yet realized */

+  result->rows_in_array = numrows;

+  result->blocksperrow = blocksperrow;

+  result->maxaccess = maxaccess;

+  result->pre_zero = pre_zero;

+  result->b_s_open = FALSE;	/* no associated backing-store object */

+  result->next = mem->virt_barray_list; /* add to list of virtual arrays */

+  mem->virt_barray_list = result;

+

+  return result;

+}

+

+

+METHODDEF(void)

+realize_virt_arrays (j_common_ptr cinfo)

+/* Allocate the in-memory buffers for any unrealized virtual arrays */

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  long space_per_minheight, maximum_space, avail_mem;

+  long minheights, max_minheights;

+  jvirt_sarray_ptr sptr;

+  jvirt_barray_ptr bptr;

+

+  /* Compute the minimum space needed (maxaccess rows in each buffer)

+   * and the maximum space needed (full image height in each buffer).

+   * These may be of use to the system-dependent jpeg_mem_available routine.

+   */

+  space_per_minheight = 0;

+  maximum_space = 0;

+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {

+    if (sptr->mem_buffer == NULL) { /* if not realized yet */

+      space_per_minheight += (long) sptr->maxaccess *

+			     (long) sptr->samplesperrow * SIZEOF(JSAMPLE);

+      maximum_space += (long) sptr->rows_in_array *

+		       (long) sptr->samplesperrow * SIZEOF(JSAMPLE);

+    }

+  }

+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {

+    if (bptr->mem_buffer == NULL) { /* if not realized yet */

+      space_per_minheight += (long) bptr->maxaccess *

+			     (long) bptr->blocksperrow * SIZEOF(JBLOCK);

+      maximum_space += (long) bptr->rows_in_array *

+		       (long) bptr->blocksperrow * SIZEOF(JBLOCK);

+    }

+  }

+

+  if (space_per_minheight <= 0)

+    return;			/* no unrealized arrays, no work */

+

+  /* Determine amount of memory to actually use; this is system-dependent. */

+  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,

+				 mem->total_space_allocated);

+

+  /* If the maximum space needed is available, make all the buffers full

+   * height; otherwise parcel it out with the same number of minheights

+   * in each buffer.

+   */

+  if (avail_mem >= maximum_space)

+    max_minheights = 1000000000L;

+  else {

+    max_minheights = avail_mem / space_per_minheight;

+    /* If there doesn't seem to be enough space, try to get the minimum

+     * anyway.  This allows a "stub" implementation of jpeg_mem_available().

+     */

+    if (max_minheights <= 0)

+      max_minheights = 1;

+  }

+

+  /* Allocate the in-memory buffers and initialize backing store as needed. */

+

+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {

+    if (sptr->mem_buffer == NULL) { /* if not realized yet */

+      minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;

+      if (minheights <= max_minheights) {

+	/* This buffer fits in memory */

+	sptr->rows_in_mem = sptr->rows_in_array;

+      } else {

+	/* It doesn't fit in memory, create backing store. */

+	sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);

+	jpeg_open_backing_store(cinfo, & sptr->b_s_info,

+				(long) sptr->rows_in_array *

+				(long) sptr->samplesperrow *

+				(long) SIZEOF(JSAMPLE));

+	sptr->b_s_open = TRUE;

+      }

+      sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,

+				      sptr->samplesperrow, sptr->rows_in_mem);

+      sptr->rowsperchunk = mem->last_rowsperchunk;

+      sptr->cur_start_row = 0;

+      sptr->first_undef_row = 0;

+      sptr->dirty = FALSE;

+    }

+  }

+

+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {

+    if (bptr->mem_buffer == NULL) { /* if not realized yet */

+      minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;

+      if (minheights <= max_minheights) {

+	/* This buffer fits in memory */

+	bptr->rows_in_mem = bptr->rows_in_array;

+      } else {

+	/* It doesn't fit in memory, create backing store. */

+	bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);

+	jpeg_open_backing_store(cinfo, & bptr->b_s_info,

+				(long) bptr->rows_in_array *

+				(long) bptr->blocksperrow *

+				(long) SIZEOF(JBLOCK));

+	bptr->b_s_open = TRUE;

+      }

+      bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,

+				      bptr->blocksperrow, bptr->rows_in_mem);

+      bptr->rowsperchunk = mem->last_rowsperchunk;

+      bptr->cur_start_row = 0;

+      bptr->first_undef_row = 0;

+      bptr->dirty = FALSE;

+    }

+  }

+}

+

+

+LOCAL(void)

+do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)

+/* Do backing store read or write of a virtual sample array */

+{

+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;

+

+  bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);

+  file_offset = ptr->cur_start_row * bytesperrow;

+  /* Loop to read or write each allocation chunk in mem_buffer */

+  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {

+    /* One chunk, but check for short chunk at end of buffer */

+    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);

+    /* Transfer no more than is currently defined */

+    thisrow = (long) ptr->cur_start_row + i;

+    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);

+    /* Transfer no more than fits in file */

+    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);

+    if (rows <= 0)		/* this chunk might be past end of file! */

+      break;

+    byte_count = rows * bytesperrow;

+    if (writing)

+      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,

+					    (void FAR *) ptr->mem_buffer[i],

+					    file_offset, byte_count);

+    else

+      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,

+					   (void FAR *) ptr->mem_buffer[i],

+					   file_offset, byte_count);

+    file_offset += byte_count;

+  }

+}

+

+

+LOCAL(void)

+do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)

+/* Do backing store read or write of a virtual coefficient-block array */

+{

+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;

+

+  bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);

+  file_offset = ptr->cur_start_row * bytesperrow;

+  /* Loop to read or write each allocation chunk in mem_buffer */

+  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {

+    /* One chunk, but check for short chunk at end of buffer */

+    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);

+    /* Transfer no more than is currently defined */

+    thisrow = (long) ptr->cur_start_row + i;

+    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);

+    /* Transfer no more than fits in file */

+    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);

+    if (rows <= 0)		/* this chunk might be past end of file! */

+      break;

+    byte_count = rows * bytesperrow;

+    if (writing)

+      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,

+					    (void FAR *) ptr->mem_buffer[i],

+					    file_offset, byte_count);

+    else

+      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,

+					   (void FAR *) ptr->mem_buffer[i],

+					   file_offset, byte_count);

+    file_offset += byte_count;

+  }

+}

+

+

+METHODDEF(JSAMPARRAY)

+access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,

+		    JDIMENSION start_row, JDIMENSION num_rows,

+		    boolean writable)

+/* Access the part of a virtual sample array starting at start_row */

+/* and extending for num_rows rows.  writable is true if  */

+/* caller intends to modify the accessed area. */

+{

+  JDIMENSION end_row = start_row + num_rows;

+  JDIMENSION undef_row;

+

+  /* debugging check */

+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||

+      ptr->mem_buffer == NULL)

+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);

+

+  /* Make the desired part of the virtual array accessible */

+  if (start_row < ptr->cur_start_row ||

+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {

+    if (! ptr->b_s_open)

+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);

+    /* Flush old buffer contents if necessary */

+    if (ptr->dirty) {

+      do_sarray_io(cinfo, ptr, TRUE);

+      ptr->dirty = FALSE;

+    }

+    /* Decide what part of virtual array to access.

+     * Algorithm: if target address > current window, assume forward scan,

+     * load starting at target address.  If target address < current window,

+     * assume backward scan, load so that target area is top of window.

+     * Note that when switching from forward write to forward read, will have

+     * start_row = 0, so the limiting case applies and we load from 0 anyway.

+     */

+    if (start_row > ptr->cur_start_row) {

+      ptr->cur_start_row = start_row;

+    } else {

+      /* use long arithmetic here to avoid overflow & unsigned problems */

+      long ltemp;

+

+      ltemp = (long) end_row - (long) ptr->rows_in_mem;

+      if (ltemp < 0)

+	ltemp = 0;		/* don't fall off front end of file */

+      ptr->cur_start_row = (JDIMENSION) ltemp;

+    }

+    /* Read in the selected part of the array.

+     * During the initial write pass, we will do no actual read

+     * because the selected part is all undefined.

+     */

+    do_sarray_io(cinfo, ptr, FALSE);

+  }

+  /* Ensure the accessed part of the array is defined; prezero if needed.

+   * To improve locality of access, we only prezero the part of the array

+   * that the caller is about to access, not the entire in-memory array.

+   */

+  if (ptr->first_undef_row < end_row) {

+    if (ptr->first_undef_row < start_row) {

+      if (writable)		/* writer skipped over a section of array */

+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);

+      undef_row = start_row;	/* but reader is allowed to read ahead */

+    } else {

+      undef_row = ptr->first_undef_row;

+    }

+    if (writable)

+      ptr->first_undef_row = end_row;

+    if (ptr->pre_zero) {

+      size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);

+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */

+      end_row -= ptr->cur_start_row;

+      while (undef_row < end_row) {

+	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);

+	undef_row++;

+      }

+    } else {

+      if (! writable)		/* reader looking at undefined data */

+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);

+    }

+  }

+  /* Flag the buffer dirty if caller will write in it */

+  if (writable)

+    ptr->dirty = TRUE;

+  /* Return address of proper part of the buffer */

+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);

+}

+

+

+METHODDEF(JBLOCKARRAY)

+access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr,

+		    JDIMENSION start_row, JDIMENSION num_rows,

+		    boolean writable)

+/* Access the part of a virtual block array starting at start_row */

+/* and extending for num_rows rows.  writable is true if  */

+/* caller intends to modify the accessed area. */

+{

+  JDIMENSION end_row = start_row + num_rows;

+  JDIMENSION undef_row;

+

+  /* debugging check */

+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||

+      ptr->mem_buffer == NULL)

+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);

+

+  /* Make the desired part of the virtual array accessible */

+  if (start_row < ptr->cur_start_row ||

+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {

+    if (! ptr->b_s_open)

+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);

+    /* Flush old buffer contents if necessary */

+    if (ptr->dirty) {

+      do_barray_io(cinfo, ptr, TRUE);

+      ptr->dirty = FALSE;

+    }

+    /* Decide what part of virtual array to access.

+     * Algorithm: if target address > current window, assume forward scan,

+     * load starting at target address.  If target address < current window,

+     * assume backward scan, load so that target area is top of window.

+     * Note that when switching from forward write to forward read, will have

+     * start_row = 0, so the limiting case applies and we load from 0 anyway.

+     */

+    if (start_row > ptr->cur_start_row) {

+      ptr->cur_start_row = start_row;

+    } else {

+      /* use long arithmetic here to avoid overflow & unsigned problems */

+      long ltemp;

+

+      ltemp = (long) end_row - (long) ptr->rows_in_mem;

+      if (ltemp < 0)

+	ltemp = 0;		/* don't fall off front end of file */

+      ptr->cur_start_row = (JDIMENSION) ltemp;

+    }

+    /* Read in the selected part of the array.

+     * During the initial write pass, we will do no actual read

+     * because the selected part is all undefined.

+     */

+    do_barray_io(cinfo, ptr, FALSE);

+  }

+  /* Ensure the accessed part of the array is defined; prezero if needed.

+   * To improve locality of access, we only prezero the part of the array

+   * that the caller is about to access, not the entire in-memory array.

+   */

+  if (ptr->first_undef_row < end_row) {

+    if (ptr->first_undef_row < start_row) {

+      if (writable)		/* writer skipped over a section of array */

+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);

+      undef_row = start_row;	/* but reader is allowed to read ahead */

+    } else {

+      undef_row = ptr->first_undef_row;

+    }

+    if (writable)

+      ptr->first_undef_row = end_row;

+    if (ptr->pre_zero) {

+      size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK);

+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */

+      end_row -= ptr->cur_start_row;

+      while (undef_row < end_row) {

+	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);

+	undef_row++;

+      }

+    } else {

+      if (! writable)		/* reader looking at undefined data */

+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);

+    }

+  }

+  /* Flag the buffer dirty if caller will write in it */

+  if (writable)

+    ptr->dirty = TRUE;

+  /* Return address of proper part of the buffer */

+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);

+}

+

+

+/*

+ * Release all objects belonging to a specified pool.

+ */

+

+METHODDEF(void)

+free_pool (j_common_ptr cinfo, int pool_id)

+{

+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;

+  small_pool_ptr shdr_ptr;

+  large_pool_ptr lhdr_ptr;

+  size_t space_freed;

+

+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)

+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

+

+#ifdef MEM_STATS

+  if (cinfo->err->trace_level > 1)

+    print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */

+#endif

+

+  /* If freeing IMAGE pool, close any virtual arrays first */

+  if (pool_id == JPOOL_IMAGE) {

+    jvirt_sarray_ptr sptr;

+    jvirt_barray_ptr bptr;

+

+    for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {

+      if (sptr->b_s_open) {	/* there may be no backing store */

+	sptr->b_s_open = FALSE;	/* prevent recursive close if error */

+	(*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info);

+      }

+    }

+    mem->virt_sarray_list = NULL;

+    for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {

+      if (bptr->b_s_open) {	/* there may be no backing store */

+	bptr->b_s_open = FALSE;	/* prevent recursive close if error */

+	(*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info);

+      }

+    }

+    mem->virt_barray_list = NULL;

+  }

+

+  /* Release large objects */

+  lhdr_ptr = mem->large_list[pool_id];

+  mem->large_list[pool_id] = NULL;

+

+  while (lhdr_ptr != NULL) {

+    large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next;

+    space_freed = lhdr_ptr->hdr.bytes_used +

+		  lhdr_ptr->hdr.bytes_left +

+		  SIZEOF(large_pool_hdr);

+    jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed);

+    mem->total_space_allocated -= space_freed;

+    lhdr_ptr = next_lhdr_ptr;

+  }

+

+  /* Release small objects */

+  shdr_ptr = mem->small_list[pool_id];

+  mem->small_list[pool_id] = NULL;

+

+  while (shdr_ptr != NULL) {

+    small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next;

+    space_freed = shdr_ptr->hdr.bytes_used +

+		  shdr_ptr->hdr.bytes_left +

+		  SIZEOF(small_pool_hdr);

+    jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed);

+    mem->total_space_allocated -= space_freed;

+    shdr_ptr = next_shdr_ptr;

+  }

+}

+

+

+/*

+ * Close up shop entirely.

+ * Note that this cannot be called unless cinfo->mem is non-NULL.

+ */

+

+METHODDEF(void)

+self_destruct (j_common_ptr cinfo)

+{

+  int pool;

+

+  /* Close all backing store, release all memory.

+   * Releasing pools in reverse order might help avoid fragmentation

+   * with some (brain-damaged) malloc libraries.

+   */

+  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {

+    free_pool(cinfo, pool);

+  }

+

+  /* Release the memory manager control block too. */

+  jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));

+  cinfo->mem = NULL;		/* ensures I will be called only once */

+

+  jpeg_mem_term(cinfo);		/* system-dependent cleanup */

+}

+

+

+/*

+ * Memory manager initialization.

+ * When this is called, only the error manager pointer is valid in cinfo!

+ */

+

+GLOBAL(void)

+jinit_memory_mgr (j_common_ptr cinfo)

+{

+  my_mem_ptr mem;

+  long max_to_use;

+  int pool;

+  size_t test_mac;

+

+  cinfo->mem = NULL;		/* for safety if init fails */

+

+  /* Check for configuration errors.

+   * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably

+   * doesn't reflect any real hardware alignment requirement.

+   * The test is a little tricky: for X>0, X and X-1 have no one-bits

+   * in common if and only if X is a power of 2, ie has only one one-bit.

+   * Some compilers may give an "unreachable code" warning here; ignore it.

+   */

+  if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0)

+    ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);

+  /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be

+   * a multiple of SIZEOF(ALIGN_TYPE).

+   * Again, an "unreachable code" warning may be ignored here.

+   * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.

+   */

+  test_mac = (size_t) MAX_ALLOC_CHUNK;

+  if ((long) test_mac != MAX_ALLOC_CHUNK ||

+      (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0)

+    ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);

+

+  max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */

+

+  /* Attempt to allocate memory manager's control block */

+  mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr));

+

+  if (mem == NULL) {

+    jpeg_mem_term(cinfo);	/* system-dependent cleanup */

+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);

+  }

+

+  /* OK, fill in the method pointers */

+  mem->pub.alloc_small = alloc_small;

+  mem->pub.alloc_large = alloc_large;

+  mem->pub.alloc_sarray = alloc_sarray;

+  mem->pub.alloc_barray = alloc_barray;

+  mem->pub.request_virt_sarray = request_virt_sarray;

+  mem->pub.request_virt_barray = request_virt_barray;

+  mem->pub.realize_virt_arrays = realize_virt_arrays;

+  mem->pub.access_virt_sarray = access_virt_sarray;

+  mem->pub.access_virt_barray = access_virt_barray;

+  mem->pub.free_pool = free_pool;

+  mem->pub.self_destruct = self_destruct;

+

+  /* Make MAX_ALLOC_CHUNK accessible to other modules */

+  mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK;

+

+  /* Initialize working state */

+  mem->pub.max_memory_to_use = max_to_use;

+

+  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {

+    mem->small_list[pool] = NULL;

+    mem->large_list[pool] = NULL;

+  }

+  mem->virt_sarray_list = NULL;

+  mem->virt_barray_list = NULL;

+

+  mem->total_space_allocated = SIZEOF(my_memory_mgr);

+

+  /* Declare ourselves open for business */

+  cinfo->mem = & mem->pub;

+

+  /* Check for an environment variable JPEGMEM; if found, override the

+   * default max_memory setting from jpeg_mem_init.  Note that the

+   * surrounding application may again override this value.

+   * If your system doesn't support getenv(), define NO_GETENV to disable

+   * this feature.

+   */

+#ifndef NO_GETENV

+  { char * memenv;

+

+    if ((memenv = getenv("JPEGMEM")) != NULL) {

+      char ch = 'x';

+

+      if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {

+	if (ch == 'm' || ch == 'M')

+	  max_to_use *= 1000L;

+	mem->pub.max_memory_to_use = max_to_use * 1000L;

+      }

+    }

+  }

+#endif

+

+}

diff --git a/test/monniaux/jpeg-6b/jpegtran.c b/test/monniaux/jpeg-6b/jpegtran.c
index 20ef111b..719aaa73 100644
--- a/test/monniaux/jpeg-6b/jpegtran.c
+++ b/test/monniaux/jpeg-6b/jpegtran.c
@@ -1,504 +1,504 @@
-/*
- * jpegtran.c
- *
- * Copyright (C) 1995-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains a command-line user interface for JPEG transcoding.
- * It is very similar to cjpeg.c, but provides lossless transcoding between
- * different JPEG file formats.  It also provides some lossless and sort-of-
- * lossless transformations of JPEG data.
- */
-
-#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */
-#include "transupp.h"		/* Support routines for jpegtran */
-#include "jversion.h"		/* for version message */
-
-#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */
-#ifdef __MWERKS__
-#include <SIOUX.h>              /* Metrowerks needs this */
-#include <console.h>		/* ... and this */
-#endif
-#ifdef THINK_C
-#include <console.h>		/* Think declares it here */
-#endif
-#endif
-
-
-/*
- * Argument-parsing code.
- * The switch parser is designed to be useful with DOS-style command line
- * syntax, ie, intermixed switches and file names, where only the switches
- * to the left of a given file name affect processing of that file.
- * The main program in this file doesn't actually use this capability...
- */
-
-
-static const char * progname;	/* program name for error messages */
-static char * outfilename;	/* for -outfile switch */
-static JCOPY_OPTION copyoption;	/* -copy switch */
-static jpeg_transform_info transformoption; /* image transformation options */
-
-
-LOCAL(void)
-usage (void)
-/* complain about bad command line */
-{
-  fprintf(stderr, "usage: %s [switches] ", progname);
-#ifdef TWO_FILE_COMMANDLINE
-  fprintf(stderr, "inputfile outputfile\n");
-#else
-  fprintf(stderr, "[inputfile]\n");
-#endif
-
-  fprintf(stderr, "Switches (names may be abbreviated):\n");
-  fprintf(stderr, "  -copy none     Copy no extra markers from source file\n");
-  fprintf(stderr, "  -copy comments Copy only comment markers (default)\n");
-  fprintf(stderr, "  -copy all      Copy all extra markers\n");
-#ifdef ENTROPY_OPT_SUPPORTED
-  fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)\n");
-#endif
-#ifdef C_PROGRESSIVE_SUPPORTED
-  fprintf(stderr, "  -progressive   Create progressive JPEG file\n");
-#endif
-#if TRANSFORMS_SUPPORTED
-  fprintf(stderr, "Switches for modifying the image:\n");
-  fprintf(stderr, "  -grayscale     Reduce to grayscale (omit color data)\n");
-  fprintf(stderr, "  -flip [horizontal|vertical]  Mirror image (left-right or top-bottom)\n");
-  fprintf(stderr, "  -rotate [90|180|270]         Rotate image (degrees clockwise)\n");
-  fprintf(stderr, "  -transpose     Transpose image\n");
-  fprintf(stderr, "  -transverse    Transverse transpose image\n");
-  fprintf(stderr, "  -trim          Drop non-transformable edge blocks\n");
-#endif /* TRANSFORMS_SUPPORTED */
-  fprintf(stderr, "Switches for advanced users:\n");
-  fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with B\n");
-  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");
-  fprintf(stderr, "  -outfile name  Specify name for output file\n");
-  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");
-  fprintf(stderr, "Switches for wizards:\n");
-#ifdef C_ARITH_CODING_SUPPORTED
-  fprintf(stderr, "  -arithmetic    Use arithmetic coding\n");
-#endif
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-  fprintf(stderr, "  -scans file    Create multi-scan JPEG per script file\n");
-#endif
-  exit(EXIT_FAILURE);
-}
-
-
-LOCAL(void)
-select_transform (JXFORM_CODE transform)
-/* Silly little routine to detect multiple transform options,
- * which we can't handle.
- */
-{
-#if TRANSFORMS_SUPPORTED
-  if (transformoption.transform == JXFORM_NONE ||
-      transformoption.transform == transform) {
-    transformoption.transform = transform;
-  } else {
-    fprintf(stderr, "%s: can only do one image transformation at a time\n",
-	    progname);
-    usage();
-  }
-#else
-  fprintf(stderr, "%s: sorry, image transformation was not compiled\n",
-	  progname);
-  exit(EXIT_FAILURE);
-#endif
-}
-
-
-LOCAL(int)
-parse_switches (j_compress_ptr cinfo, int argc, char **argv,
-		int last_file_arg_seen, boolean for_real)
-/* Parse optional switches.
- * Returns argv[] index of first file-name argument (== argc if none).
- * Any file names with indexes <= last_file_arg_seen are ignored;
- * they have presumably been processed in a previous iteration.
- * (Pass 0 for last_file_arg_seen on the first or only iteration.)
- * for_real is FALSE on the first (dummy) pass; we may skip any expensive
- * processing.
- */
-{
-  int argn;
-  char * arg;
-  boolean simple_progressive;
-  char * scansarg = NULL;	/* saves -scans parm if any */
-
-  /* Set up default JPEG parameters. */
-  simple_progressive = FALSE;
-  outfilename = NULL;
-  copyoption = JCOPYOPT_DEFAULT;
-  transformoption.transform = JXFORM_NONE;
-  transformoption.trim = FALSE;
-  transformoption.force_grayscale = FALSE;
-  cinfo->err->trace_level = 0;
-
-  /* Scan command line options, adjust parameters */
-
-  for (argn = 1; argn < argc; argn++) {
-    arg = argv[argn];
-    if (*arg != '-') {
-      /* Not a switch, must be a file name argument */
-      if (argn <= last_file_arg_seen) {
-	outfilename = NULL;	/* -outfile applies to just one input file */
-	continue;		/* ignore this name if previously processed */
-      }
-      break;			/* else done parsing switches */
-    }
-    arg++;			/* advance past switch marker character */
-
-    if (keymatch(arg, "arithmetic", 1)) {
-      /* Use arithmetic coding. */
-#ifdef C_ARITH_CODING_SUPPORTED
-      cinfo->arith_code = TRUE;
-#else
-      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "copy", 1)) {
-      /* Select which extra markers to copy. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (keymatch(argv[argn], "none", 1)) {
-	copyoption = JCOPYOPT_NONE;
-      } else if (keymatch(argv[argn], "comments", 1)) {
-	copyoption = JCOPYOPT_COMMENTS;
-      } else if (keymatch(argv[argn], "all", 1)) {
-	copyoption = JCOPYOPT_ALL;
-      } else
-	usage();
-
-    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
-      /* Enable debug printouts. */
-      /* On first -d, print version identification */
-      static boolean printed_version = FALSE;
-
-      if (! printed_version) {
-	fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %s\n%s\n",
-		JVERSION, JCOPYRIGHT);
-	printed_version = TRUE;
-      }
-      cinfo->err->trace_level++;
-
-    } else if (keymatch(arg, "flip", 1)) {
-      /* Mirror left-right or top-bottom. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (keymatch(argv[argn], "horizontal", 1))
-	select_transform(JXFORM_FLIP_H);
-      else if (keymatch(argv[argn], "vertical", 1))
-	select_transform(JXFORM_FLIP_V);
-      else
-	usage();
-
-    } else if (keymatch(arg, "grayscale", 1) || keymatch(arg, "greyscale",1)) {
-      /* Force to grayscale. */
-#if TRANSFORMS_SUPPORTED
-      transformoption.force_grayscale = TRUE;
-#else
-      select_transform(JXFORM_NONE);	/* force an error */
-#endif
-
-    } else if (keymatch(arg, "maxmemory", 3)) {
-      /* Maximum memory in Kb (or Mb with 'm'). */
-      long lval;
-      char ch = 'x';
-
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
-	usage();
-      if (ch == 'm' || ch == 'M')
-	lval *= 1000L;
-      cinfo->mem->max_memory_to_use = lval * 1000L;
-
-    } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
-      /* Enable entropy parm optimization. */
-#ifdef ENTROPY_OPT_SUPPORTED
-      cinfo->optimize_coding = TRUE;
-#else
-      fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "outfile", 4)) {
-      /* Set output file name. */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      outfilename = argv[argn];	/* save it away for later use */
-
-    } else if (keymatch(arg, "progressive", 1)) {
-      /* Select simple progressive mode. */
-#ifdef C_PROGRESSIVE_SUPPORTED
-      simple_progressive = TRUE;
-      /* We must postpone execution until num_components is known. */
-#else
-      fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "restart", 1)) {
-      /* Restart interval in MCU rows (or in MCUs with 'b'). */
-      long lval;
-      char ch = 'x';
-
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
-	usage();
-      if (lval < 0 || lval > 65535L)
-	usage();
-      if (ch == 'b' || ch == 'B') {
-	cinfo->restart_interval = (unsigned int) lval;
-	cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
-      } else {
-	cinfo->restart_in_rows = (int) lval;
-	/* restart_interval will be computed during startup */
-      }
-
-    } else if (keymatch(arg, "rotate", 2)) {
-      /* Rotate 90, 180, or 270 degrees (measured clockwise). */
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      if (keymatch(argv[argn], "90", 2))
-	select_transform(JXFORM_ROT_90);
-      else if (keymatch(argv[argn], "180", 3))
-	select_transform(JXFORM_ROT_180);
-      else if (keymatch(argv[argn], "270", 3))
-	select_transform(JXFORM_ROT_270);
-      else
-	usage();
-
-    } else if (keymatch(arg, "scans", 1)) {
-      /* Set scan script. */
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-      if (++argn >= argc)	/* advance to next argument */
-	usage();
-      scansarg = argv[argn];
-      /* We must postpone reading the file in case -progressive appears. */
-#else
-      fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
-	      progname);
-      exit(EXIT_FAILURE);
-#endif
-
-    } else if (keymatch(arg, "transpose", 1)) {
-      /* Transpose (across UL-to-LR axis). */
-      select_transform(JXFORM_TRANSPOSE);
-
-    } else if (keymatch(arg, "transverse", 6)) {
-      /* Transverse transpose (across UR-to-LL axis). */
-      select_transform(JXFORM_TRANSVERSE);
-
-    } else if (keymatch(arg, "trim", 3)) {
-      /* Trim off any partial edge MCUs that the transform can't handle. */
-      transformoption.trim = TRUE;
-
-    } else {
-      usage();			/* bogus switch */
-    }
-  }
-
-  /* Post-switch-scanning cleanup */
-
-  if (for_real) {
-
-#ifdef C_PROGRESSIVE_SUPPORTED
-    if (simple_progressive)	/* process -progressive; -scans can override */
-      jpeg_simple_progression(cinfo);
-#endif
-
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-    if (scansarg != NULL)	/* process -scans if it was present */
-      if (! read_scan_script(cinfo, scansarg))
-	usage();
-#endif
-  }
-
-  return argn;			/* return index of next arg (file name) */
-}
-
-
-/*
- * The main program.
- */
-
-int
-main (int argc, char **argv)
-{
-  struct jpeg_decompress_struct srcinfo;
-  struct jpeg_compress_struct dstinfo;
-  struct jpeg_error_mgr jsrcerr, jdsterr;
-#ifdef PROGRESS_REPORT
-  struct cdjpeg_progress_mgr progress;
-#endif
-  jvirt_barray_ptr * src_coef_arrays;
-  jvirt_barray_ptr * dst_coef_arrays;
-  int file_index;
-  FILE * input_file;
-  FILE * output_file;
-
-  /* On Mac, fetch a command line. */
-#ifdef USE_CCOMMAND
-  argc = ccommand(&argv);
-#endif
-
-  progname = argv[0];
-  if (progname == NULL || progname[0] == 0)
-    progname = "jpegtran";	/* in case C library doesn't provide it */
-
-  /* Initialize the JPEG decompression object with default error handling. */
-  srcinfo.err = jpeg_std_error(&jsrcerr);
-  jpeg_create_decompress(&srcinfo);
-  /* Initialize the JPEG compression object with default error handling. */
-  dstinfo.err = jpeg_std_error(&jdsterr);
-  jpeg_create_compress(&dstinfo);
-
-  /* Now safe to enable signal catcher.
-   * Note: we assume only the decompression object will have virtual arrays.
-   */
-#ifdef NEED_SIGNAL_CATCHER
-  enable_signal_catcher((j_common_ptr) &srcinfo);
-#endif
-
-  /* Scan command line to find file names.
-   * It is convenient to use just one switch-parsing routine, but the switch
-   * values read here are mostly ignored; we will rescan the switches after
-   * opening the input file.  Also note that most of the switches affect the
-   * destination JPEG object, so we parse into that and then copy over what
-   * needs to affects the source too.
-   */
-
-  file_index = parse_switches(&dstinfo, argc, argv, 0, FALSE);
-  jsrcerr.trace_level = jdsterr.trace_level;
-  srcinfo.mem->max_memory_to_use = dstinfo.mem->max_memory_to_use;
-
-#ifdef TWO_FILE_COMMANDLINE
-  /* Must have either -outfile switch or explicit output file name */
-  if (outfilename == NULL) {
-    if (file_index != argc-2) {
-      fprintf(stderr, "%s: must name one input and one output file\n",
-	      progname);
-      usage();
-    }
-    outfilename = argv[file_index+1];
-  } else {
-    if (file_index != argc-1) {
-      fprintf(stderr, "%s: must name one input and one output file\n",
-	      progname);
-      usage();
-    }
-  }
-#else
-  /* Unix style: expect zero or one file name */
-  if (file_index < argc-1) {
-    fprintf(stderr, "%s: only one input file\n", progname);
-    usage();
-  }
-#endif /* TWO_FILE_COMMANDLINE */
-
-  /* Open the input file. */
-  if (file_index < argc) {
-    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default input file is stdin */
-    input_file = read_stdin();
-  }
-
-  /* Open the output file. */
-  if (outfilename != NULL) {
-    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default output file is stdout */
-    output_file = write_stdout();
-  }
-
-#ifdef PROGRESS_REPORT
-  start_progress_monitor((j_common_ptr) &dstinfo, &progress);
-#endif
-
-  /* Specify data source for decompression */
-  jpeg_stdio_src(&srcinfo, input_file);
-
-  /* Enable saving of extra markers that we want to copy */
-  jcopy_markers_setup(&srcinfo, copyoption);
-
-  /* Read file header */
-  (void) jpeg_read_header(&srcinfo, TRUE);
-
-  /* Any space needed by a transform option must be requested before
-   * jpeg_read_coefficients so that memory allocation will be done right.
-   */
-#if TRANSFORMS_SUPPORTED
-  jtransform_request_workspace(&srcinfo, &transformoption);
-#endif
-
-  /* Read source file as DCT coefficients */
-  src_coef_arrays = jpeg_read_coefficients(&srcinfo);
-
-  /* Initialize destination compression parameters from source values */
-  jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
-
-  /* Adjust destination parameters if required by transform options;
-   * also find out which set of coefficient arrays will hold the output.
-   */
-#if TRANSFORMS_SUPPORTED
-  dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo,
-						 src_coef_arrays,
-						 &transformoption);
-#else
-  dst_coef_arrays = src_coef_arrays;
-#endif
-
-  /* Adjust default compression parameters by re-parsing the options */
-  file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE);
-
-  /* Specify data destination for compression */
-  jpeg_stdio_dest(&dstinfo, output_file);
-
-  /* Start compressor (note no image data is actually written here) */
-  jpeg_write_coefficients(&dstinfo, dst_coef_arrays);
-
-  /* Copy to the output file any extra markers that we want to preserve */
-  jcopy_markers_execute(&srcinfo, &dstinfo, copyoption);
-
-  /* Execute image transformation, if any */
-#if TRANSFORMS_SUPPORTED
-  jtransform_execute_transformation(&srcinfo, &dstinfo,
-				    src_coef_arrays,
-				    &transformoption);
-#endif
-
-  /* Finish compression and release memory */
-  jpeg_finish_compress(&dstinfo);
-  jpeg_destroy_compress(&dstinfo);
-  (void) jpeg_finish_decompress(&srcinfo);
-  jpeg_destroy_decompress(&srcinfo);
-
-  /* Close files, if we opened them */
-  if (input_file != stdin)
-    fclose(input_file);
-  if (output_file != stdout)
-    fclose(output_file);
-
-#ifdef PROGRESS_REPORT
-  end_progress_monitor((j_common_ptr) &dstinfo);
-#endif
-
-  /* All done. */
-  exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS);
-  return 0;			/* suppress no-return-value warnings */
-}
+/*

+ * jpegtran.c

+ *

+ * Copyright (C) 1995-1997, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains a command-line user interface for JPEG transcoding.

+ * It is very similar to cjpeg.c, but provides lossless transcoding between

+ * different JPEG file formats.  It also provides some lossless and sort-of-

+ * lossless transformations of JPEG data.

+ */

+

+#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */

+#include "transupp.h"		/* Support routines for jpegtran */

+#include "jversion.h"		/* for version message */

+

+#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */

+#ifdef __MWERKS__

+#include <SIOUX.h>              /* Metrowerks needs this */

+#include <console.h>		/* ... and this */

+#endif

+#ifdef THINK_C

+#include <console.h>		/* Think declares it here */

+#endif

+#endif

+

+

+/*

+ * Argument-parsing code.

+ * The switch parser is designed to be useful with DOS-style command line

+ * syntax, ie, intermixed switches and file names, where only the switches

+ * to the left of a given file name affect processing of that file.

+ * The main program in this file doesn't actually use this capability...

+ */

+

+

+static const char * progname;	/* program name for error messages */

+static char * outfilename;	/* for -outfile switch */

+static JCOPY_OPTION copyoption;	/* -copy switch */

+static jpeg_transform_info transformoption; /* image transformation options */

+

+

+LOCAL(void)

+usage (void)

+/* complain about bad command line */

+{

+  fprintf(stderr, "usage: %s [switches] ", progname);

+#ifdef TWO_FILE_COMMANDLINE

+  fprintf(stderr, "inputfile outputfile\n");

+#else

+  fprintf(stderr, "[inputfile]\n");

+#endif

+

+  fprintf(stderr, "Switches (names may be abbreviated):\n");

+  fprintf(stderr, "  -copy none     Copy no extra markers from source file\n");

+  fprintf(stderr, "  -copy comments Copy only comment markers (default)\n");

+  fprintf(stderr, "  -copy all      Copy all extra markers\n");

+#ifdef ENTROPY_OPT_SUPPORTED

+  fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)\n");

+#endif

+#ifdef C_PROGRESSIVE_SUPPORTED

+  fprintf(stderr, "  -progressive   Create progressive JPEG file\n");

+#endif

+#if TRANSFORMS_SUPPORTED

+  fprintf(stderr, "Switches for modifying the image:\n");

+  fprintf(stderr, "  -grayscale     Reduce to grayscale (omit color data)\n");

+  fprintf(stderr, "  -flip [horizontal|vertical]  Mirror image (left-right or top-bottom)\n");

+  fprintf(stderr, "  -rotate [90|180|270]         Rotate image (degrees clockwise)\n");

+  fprintf(stderr, "  -transpose     Transpose image\n");

+  fprintf(stderr, "  -transverse    Transverse transpose image\n");

+  fprintf(stderr, "  -trim          Drop non-transformable edge blocks\n");

+#endif /* TRANSFORMS_SUPPORTED */

+  fprintf(stderr, "Switches for advanced users:\n");

+  fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with B\n");

+  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");

+  fprintf(stderr, "  -outfile name  Specify name for output file\n");

+  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");

+  fprintf(stderr, "Switches for wizards:\n");

+#ifdef C_ARITH_CODING_SUPPORTED

+  fprintf(stderr, "  -arithmetic    Use arithmetic coding\n");

+#endif

+#ifdef C_MULTISCAN_FILES_SUPPORTED

+  fprintf(stderr, "  -scans file    Create multi-scan JPEG per script file\n");

+#endif

+  exit(EXIT_FAILURE);

+}

+

+

+LOCAL(void)

+select_transform (JXFORM_CODE transform)

+/* Silly little routine to detect multiple transform options,

+ * which we can't handle.

+ */

+{

+#if TRANSFORMS_SUPPORTED

+  if (transformoption.transform == JXFORM_NONE ||

+      transformoption.transform == transform) {

+    transformoption.transform = transform;

+  } else {

+    fprintf(stderr, "%s: can only do one image transformation at a time\n",

+	    progname);

+    usage();

+  }

+#else

+  fprintf(stderr, "%s: sorry, image transformation was not compiled\n",

+	  progname);

+  exit(EXIT_FAILURE);

+#endif

+}

+

+

+LOCAL(int)

+parse_switches (j_compress_ptr cinfo, int argc, char **argv,

+		int last_file_arg_seen, boolean for_real)

+/* Parse optional switches.

+ * Returns argv[] index of first file-name argument (== argc if none).

+ * Any file names with indexes <= last_file_arg_seen are ignored;

+ * they have presumably been processed in a previous iteration.

+ * (Pass 0 for last_file_arg_seen on the first or only iteration.)

+ * for_real is FALSE on the first (dummy) pass; we may skip any expensive

+ * processing.

+ */

+{

+  int argn;

+  char * arg;

+  boolean simple_progressive;

+  char * scansarg = NULL;	/* saves -scans parm if any */

+

+  /* Set up default JPEG parameters. */

+  simple_progressive = FALSE;

+  outfilename = NULL;

+  copyoption = JCOPYOPT_DEFAULT;

+  transformoption.transform = JXFORM_NONE;

+  transformoption.trim = FALSE;

+  transformoption.force_grayscale = FALSE;

+  cinfo->err->trace_level = 0;

+

+  /* Scan command line options, adjust parameters */

+

+  for (argn = 1; argn < argc; argn++) {

+    arg = argv[argn];

+    if (*arg != '-') {

+      /* Not a switch, must be a file name argument */

+      if (argn <= last_file_arg_seen) {

+	outfilename = NULL;	/* -outfile applies to just one input file */

+	continue;		/* ignore this name if previously processed */

+      }

+      break;			/* else done parsing switches */

+    }

+    arg++;			/* advance past switch marker character */

+

+    if (keymatch(arg, "arithmetic", 1)) {

+      /* Use arithmetic coding. */

+#ifdef C_ARITH_CODING_SUPPORTED

+      cinfo->arith_code = TRUE;

+#else

+      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "copy", 1)) {

+      /* Select which extra markers to copy. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (keymatch(argv[argn], "none", 1)) {

+	copyoption = JCOPYOPT_NONE;

+      } else if (keymatch(argv[argn], "comments", 1)) {

+	copyoption = JCOPYOPT_COMMENTS;

+      } else if (keymatch(argv[argn], "all", 1)) {

+	copyoption = JCOPYOPT_ALL;

+      } else

+	usage();

+

+    } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {

+      /* Enable debug printouts. */

+      /* On first -d, print version identification */

+      static boolean printed_version = FALSE;

+

+      if (! printed_version) {

+	fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %s\n%s\n",

+		JVERSION, JCOPYRIGHT);

+	printed_version = TRUE;

+      }

+      cinfo->err->trace_level++;

+

+    } else if (keymatch(arg, "flip", 1)) {

+      /* Mirror left-right or top-bottom. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (keymatch(argv[argn], "horizontal", 1))

+	select_transform(JXFORM_FLIP_H);

+      else if (keymatch(argv[argn], "vertical", 1))

+	select_transform(JXFORM_FLIP_V);

+      else

+	usage();

+

+    } else if (keymatch(arg, "grayscale", 1) || keymatch(arg, "greyscale",1)) {

+      /* Force to grayscale. */

+#if TRANSFORMS_SUPPORTED

+      transformoption.force_grayscale = TRUE;

+#else

+      select_transform(JXFORM_NONE);	/* force an error */

+#endif

+

+    } else if (keymatch(arg, "maxmemory", 3)) {

+      /* Maximum memory in Kb (or Mb with 'm'). */

+      long lval;

+      char ch = 'x';

+

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)

+	usage();

+      if (ch == 'm' || ch == 'M')

+	lval *= 1000L;

+      cinfo->mem->max_memory_to_use = lval * 1000L;

+

+    } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {

+      /* Enable entropy parm optimization. */

+#ifdef ENTROPY_OPT_SUPPORTED

+      cinfo->optimize_coding = TRUE;

+#else

+      fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "outfile", 4)) {

+      /* Set output file name. */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      outfilename = argv[argn];	/* save it away for later use */

+

+    } else if (keymatch(arg, "progressive", 1)) {

+      /* Select simple progressive mode. */

+#ifdef C_PROGRESSIVE_SUPPORTED

+      simple_progressive = TRUE;

+      /* We must postpone execution until num_components is known. */

+#else

+      fprintf(stderr, "%s: sorry, progressive output was not compiled\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "restart", 1)) {

+      /* Restart interval in MCU rows (or in MCUs with 'b'). */

+      long lval;

+      char ch = 'x';

+

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)

+	usage();

+      if (lval < 0 || lval > 65535L)

+	usage();

+      if (ch == 'b' || ch == 'B') {

+	cinfo->restart_interval = (unsigned int) lval;

+	cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */

+      } else {

+	cinfo->restart_in_rows = (int) lval;

+	/* restart_interval will be computed during startup */

+      }

+

+    } else if (keymatch(arg, "rotate", 2)) {

+      /* Rotate 90, 180, or 270 degrees (measured clockwise). */

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      if (keymatch(argv[argn], "90", 2))

+	select_transform(JXFORM_ROT_90);

+      else if (keymatch(argv[argn], "180", 3))

+	select_transform(JXFORM_ROT_180);

+      else if (keymatch(argv[argn], "270", 3))

+	select_transform(JXFORM_ROT_270);

+      else

+	usage();

+

+    } else if (keymatch(arg, "scans", 1)) {

+      /* Set scan script. */

+#ifdef C_MULTISCAN_FILES_SUPPORTED

+      if (++argn >= argc)	/* advance to next argument */

+	usage();

+      scansarg = argv[argn];

+      /* We must postpone reading the file in case -progressive appears. */

+#else

+      fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",

+	      progname);

+      exit(EXIT_FAILURE);

+#endif

+

+    } else if (keymatch(arg, "transpose", 1)) {

+      /* Transpose (across UL-to-LR axis). */

+      select_transform(JXFORM_TRANSPOSE);

+

+    } else if (keymatch(arg, "transverse", 6)) {

+      /* Transverse transpose (across UR-to-LL axis). */

+      select_transform(JXFORM_TRANSVERSE);

+

+    } else if (keymatch(arg, "trim", 3)) {

+      /* Trim off any partial edge MCUs that the transform can't handle. */

+      transformoption.trim = TRUE;

+

+    } else {

+      usage();			/* bogus switch */

+    }

+  }

+

+  /* Post-switch-scanning cleanup */

+

+  if (for_real) {

+

+#ifdef C_PROGRESSIVE_SUPPORTED

+    if (simple_progressive)	/* process -progressive; -scans can override */

+      jpeg_simple_progression(cinfo);

+#endif

+

+#ifdef C_MULTISCAN_FILES_SUPPORTED

+    if (scansarg != NULL)	/* process -scans if it was present */

+      if (! read_scan_script(cinfo, scansarg))

+	usage();

+#endif

+  }

+

+  return argn;			/* return index of next arg (file name) */

+}

+

+

+/*

+ * The main program.

+ */

+

+int

+main (int argc, char **argv)

+{

+  struct jpeg_decompress_struct srcinfo;

+  struct jpeg_compress_struct dstinfo;

+  struct jpeg_error_mgr jsrcerr, jdsterr;

+#ifdef PROGRESS_REPORT

+  struct cdjpeg_progress_mgr progress;

+#endif

+  jvirt_barray_ptr * src_coef_arrays;

+  jvirt_barray_ptr * dst_coef_arrays;

+  int file_index;

+  FILE * input_file;

+  FILE * output_file;

+

+  /* On Mac, fetch a command line. */

+#ifdef USE_CCOMMAND

+  argc = ccommand(&argv);

+#endif

+

+  progname = argv[0];

+  if (progname == NULL || progname[0] == 0)

+    progname = "jpegtran";	/* in case C library doesn't provide it */

+

+  /* Initialize the JPEG decompression object with default error handling. */

+  srcinfo.err = jpeg_std_error(&jsrcerr);

+  jpeg_create_decompress(&srcinfo);

+  /* Initialize the JPEG compression object with default error handling. */

+  dstinfo.err = jpeg_std_error(&jdsterr);

+  jpeg_create_compress(&dstinfo);

+

+  /* Now safe to enable signal catcher.

+   * Note: we assume only the decompression object will have virtual arrays.

+   */

+#ifdef NEED_SIGNAL_CATCHER

+  enable_signal_catcher((j_common_ptr) &srcinfo);

+#endif

+

+  /* Scan command line to find file names.

+   * It is convenient to use just one switch-parsing routine, but the switch

+   * values read here are mostly ignored; we will rescan the switches after

+   * opening the input file.  Also note that most of the switches affect the

+   * destination JPEG object, so we parse into that and then copy over what

+   * needs to affects the source too.

+   */

+

+  file_index = parse_switches(&dstinfo, argc, argv, 0, FALSE);

+  jsrcerr.trace_level = jdsterr.trace_level;

+  srcinfo.mem->max_memory_to_use = dstinfo.mem->max_memory_to_use;

+

+#ifdef TWO_FILE_COMMANDLINE

+  /* Must have either -outfile switch or explicit output file name */

+  if (outfilename == NULL) {

+    if (file_index != argc-2) {

+      fprintf(stderr, "%s: must name one input and one output file\n",

+	      progname);

+      usage();

+    }

+    outfilename = argv[file_index+1];

+  } else {

+    if (file_index != argc-1) {

+      fprintf(stderr, "%s: must name one input and one output file\n",

+	      progname);

+      usage();

+    }

+  }

+#else

+  /* Unix style: expect zero or one file name */

+  if (file_index < argc-1) {

+    fprintf(stderr, "%s: only one input file\n", progname);

+    usage();

+  }

+#endif /* TWO_FILE_COMMANDLINE */

+

+  /* Open the input file. */

+  if (file_index < argc) {

+    if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default input file is stdin */

+    input_file = read_stdin();

+  }

+

+  /* Open the output file. */

+  if (outfilename != NULL) {

+    if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, outfilename);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default output file is stdout */

+    output_file = write_stdout();

+  }

+

+#ifdef PROGRESS_REPORT

+  start_progress_monitor((j_common_ptr) &dstinfo, &progress);

+#endif

+

+  /* Specify data source for decompression */

+  jpeg_stdio_src(&srcinfo, input_file);

+

+  /* Enable saving of extra markers that we want to copy */

+  jcopy_markers_setup(&srcinfo, copyoption);

+

+  /* Read file header */

+  (void) jpeg_read_header(&srcinfo, TRUE);

+

+  /* Any space needed by a transform option must be requested before

+   * jpeg_read_coefficients so that memory allocation will be done right.

+   */

+#if TRANSFORMS_SUPPORTED

+  jtransform_request_workspace(&srcinfo, &transformoption);

+#endif

+

+  /* Read source file as DCT coefficients */

+  src_coef_arrays = jpeg_read_coefficients(&srcinfo);

+

+  /* Initialize destination compression parameters from source values */

+  jpeg_copy_critical_parameters(&srcinfo, &dstinfo);

+

+  /* Adjust destination parameters if required by transform options;

+   * also find out which set of coefficient arrays will hold the output.

+   */

+#if TRANSFORMS_SUPPORTED

+  dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo,

+						 src_coef_arrays,

+						 &transformoption);

+#else

+  dst_coef_arrays = src_coef_arrays;

+#endif

+

+  /* Adjust default compression parameters by re-parsing the options */

+  file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE);

+

+  /* Specify data destination for compression */

+  jpeg_stdio_dest(&dstinfo, output_file);

+

+  /* Start compressor (note no image data is actually written here) */

+  jpeg_write_coefficients(&dstinfo, dst_coef_arrays);

+

+  /* Copy to the output file any extra markers that we want to preserve */

+  jcopy_markers_execute(&srcinfo, &dstinfo, copyoption);

+

+  /* Execute image transformation, if any */

+#if TRANSFORMS_SUPPORTED

+  jtransform_execute_transformation(&srcinfo, &dstinfo,

+				    src_coef_arrays,

+				    &transformoption);

+#endif

+

+  /* Finish compression and release memory */

+  jpeg_finish_compress(&dstinfo);

+  jpeg_destroy_compress(&dstinfo);

+  (void) jpeg_finish_decompress(&srcinfo);

+  jpeg_destroy_decompress(&srcinfo);

+

+  /* Close files, if we opened them */

+  if (input_file != stdin)

+    fclose(input_file);

+  if (output_file != stdout)

+    fclose(output_file);

+

+#ifdef PROGRESS_REPORT

+  end_progress_monitor((j_common_ptr) &dstinfo);

+#endif

+

+  /* All done. */

+  exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS);

+  return 0;			/* suppress no-return-value warnings */

+}

diff --git a/test/monniaux/jpeg-6b/jquant1.c b/test/monniaux/jpeg-6b/jquant1.c
index b2f96aa1..9f5d67bc 100644
--- a/test/monniaux/jpeg-6b/jquant1.c
+++ b/test/monniaux/jpeg-6b/jquant1.c
@@ -227,7 +227,7 @@ select_ncolors (j_decompress_ptr cinfo, int Ncolors[])
     for (i = 0; i < nc; i++) {
       j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i);
       /* calculate new total_colors if Ncolors[j] is incremented */
-      temp = total_colors / Ncolors[j];
+      temp = INT_DIV(total_colors, Ncolors[j]);
       temp *= Ncolors[j]+1;	/* done in long arith to avoid oflo */
       if (temp > (long) max_colors)
 	break;			/* won't fit, done with this pass */
@@ -251,7 +251,7 @@ output_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
    * (Forcing the upper and lower values to the limits ensures that
    * dithering can't produce a color outside the selected gamut.)
    */
-  return (int) (((INT32) j * MAXJSAMPLE + maxj/2) / maxj);
+  return (int) INT_DIV(((INT32) j * MAXJSAMPLE + maxj/2), maxj);
 }
 
 
@@ -261,7 +261,7 @@ largest_input_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
 /* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */
 {
   /* Breakpoints are halfway between values returned by output_value */
-  return (int) (((INT32) (2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj));
+  return (int) INT_DIV(((INT32) (2*j + 1) * MAXJSAMPLE + maxj), (2*maxj));
 }
 
 
@@ -303,7 +303,7 @@ create_colormap (j_decompress_ptr cinfo)
   for (i = 0; i < cinfo->out_color_components; i++) {
     /* fill in colormap entries for i'th color component */
     nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
-    blksize = blkdist / nci;
+    blksize = INT_DIV(blkdist, nci);
     for (j = 0; j < nci; j++) {
       /* Compute j'th output value (out of nci) for component */
       val = output_value(cinfo, i, j, nci-1);
@@ -360,7 +360,7 @@ create_colorindex (j_decompress_ptr cinfo)
   for (i = 0; i < cinfo->out_color_components; i++) {
     /* fill in colorindex entries for i'th color component */
     nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
-    blksize = blksize / nci;
+    blksize = INT_DIV(blksize, nci);
 
     /* adjust colorindex pointers to provide padding at negative indexes. */
     if (pad)
@@ -415,7 +415,7 @@ make_odither_array (j_decompress_ptr cinfo, int ncolors)
       /* Ensure round towards zero despite C's lack of consistency
        * about rounding negative values in integer division...
        */
-      odither[j][k] = (int) (num<0 ? -((-num)/den) : num/den);
+      odither[j][k] = (int) (num<0 ? -INT_DIV((-num),den) : INT_DIV(num,den));
     }
   }
   return odither;
@@ -787,6 +787,7 @@ start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
     ERREXIT(cinfo, JERR_NOT_COMPILED);
     break;
   }
+  KILL_TAIL_CALL();
 }
 
 
@@ -810,6 +811,7 @@ METHODDEF(void)
 new_color_map_1_quant (j_decompress_ptr cinfo)
 {
   ERREXIT(cinfo, JERR_MODE_CHANGE);
+  KILL_TAIL_CALL();
 }
 
 
diff --git a/test/monniaux/jpeg-6b/jquant2.c b/test/monniaux/jpeg-6b/jquant2.c
index af601e33..6eb3bb17 100644
--- a/test/monniaux/jpeg-6b/jquant2.c
+++ b/test/monniaux/jpeg-6b/jquant2.c
@@ -529,9 +529,9 @@ compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor)
       }
     }
   
-  cinfo->colormap[0][icolor] = (JSAMPLE) ((c0total + (total>>1)) / total);
-  cinfo->colormap[1][icolor] = (JSAMPLE) ((c1total + (total>>1)) / total);
-  cinfo->colormap[2][icolor] = (JSAMPLE) ((c2total + (total>>1)) / total);
+  cinfo->colormap[0][icolor] = (JSAMPLE) INT_DIV((c0total + (total>>1)), total);
+  cinfo->colormap[1][icolor] = (JSAMPLE) INT_DIV((c1total + (total>>1)), total);
+  cinfo->colormap[2][icolor] = (JSAMPLE) INT_DIV((c2total + (total>>1)), total);
 }
 
 
diff --git a/test/monniaux/jpeg-6b/rdbmp.c b/test/monniaux/jpeg-6b/rdbmp.c
index 3957ba46..e999a56b 100644
--- a/test/monniaux/jpeg-6b/rdbmp.c
+++ b/test/monniaux/jpeg-6b/rdbmp.c
@@ -338,8 +338,8 @@ start_input_bmp (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 
     if (biXPelsPerMeter > 0 && biYPelsPerMeter > 0) {
       /* Set JFIF density parameters from the BMP data */
-      cinfo->X_density = (UINT16) (biXPelsPerMeter/100); /* 100 cm per meter */
-      cinfo->Y_density = (UINT16) (biYPelsPerMeter/100);
+      cinfo->X_density = (UINT16) INT_DIV(biXPelsPerMeter, 100); /* 100 cm per meter */
+      cinfo->Y_density = (UINT16) INT_DIV(biYPelsPerMeter, 100);
       cinfo->density_unit = 2;	/* dots/cm */
     }
     break;
diff --git a/test/monniaux/jpeg-6b/rdgif.c b/test/monniaux/jpeg-6b/rdgif.c
index b27c1675..b0757e71 100644
--- a/test/monniaux/jpeg-6b/rdgif.c
+++ b/test/monniaux/jpeg-6b/rdgif.c
@@ -1,38 +1,38 @@
-/*
- * rdgif.c
- *
- * Copyright (C) 1991-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains routines to read input images in GIF format.
- *
- *****************************************************************************
- * NOTE: to avoid entanglements with Unisys' patent on LZW compression,      *
- * the ability to read GIF files has been removed from the IJG distribution. *
- * Sorry about that.                                                         *
- *****************************************************************************
- *
- * We are required to state that
- *    "The Graphics Interchange Format(c) is the Copyright property of
- *    CompuServe Incorporated. GIF(sm) is a Service Mark property of
- *    CompuServe Incorporated."
- */
-
-#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */
-
-#ifdef GIF_SUPPORTED
-
-/*
- * The module selection routine for GIF format input.
- */
-
-GLOBAL(cjpeg_source_ptr)
-jinit_read_gif (j_compress_ptr cinfo)
-{
-  fprintf(stderr, "GIF input is unsupported for legal reasons.  Sorry.\n");
-  exit(EXIT_FAILURE);
-  return NULL;			/* keep compiler happy */
-}
-
-#endif /* GIF_SUPPORTED */
+/*

+ * rdgif.c

+ *

+ * Copyright (C) 1991-1997, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains routines to read input images in GIF format.

+ *

+ *****************************************************************************

+ * NOTE: to avoid entanglements with Unisys' patent on LZW compression,      *

+ * the ability to read GIF files has been removed from the IJG distribution. *

+ * Sorry about that.                                                         *

+ *****************************************************************************

+ *

+ * We are required to state that

+ *    "The Graphics Interchange Format(c) is the Copyright property of

+ *    CompuServe Incorporated. GIF(sm) is a Service Mark property of

+ *    CompuServe Incorporated."

+ */

+

+#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */

+

+#ifdef GIF_SUPPORTED

+

+/*

+ * The module selection routine for GIF format input.

+ */

+

+GLOBAL(cjpeg_source_ptr)

+jinit_read_gif (j_compress_ptr cinfo)

+{

+  fprintf(stderr, "GIF input is unsupported for legal reasons.  Sorry.\n");

+  exit(EXIT_FAILURE);

+  return NULL;			/* keep compiler happy */

+}

+

+#endif /* GIF_SUPPORTED */

diff --git a/test/monniaux/jpeg-6b/rdjpgcom.c b/test/monniaux/jpeg-6b/rdjpgcom.c
index ffe6fc62..c8b94bb8 100644
--- a/test/monniaux/jpeg-6b/rdjpgcom.c
+++ b/test/monniaux/jpeg-6b/rdjpgcom.c
@@ -1,496 +1,496 @@
-/*
- * rdjpgcom.c
- *
- * Copyright (C) 1994-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains a very simple stand-alone application that displays
- * the text in COM (comment) markers in a JFIF file.
- * This may be useful as an example of the minimum logic needed to parse
- * JPEG markers.
- */
-
-#define JPEG_CJPEG_DJPEG	/* to get the command-line config symbols */
-#include "jinclude.h"		/* get auto-config symbols, <stdio.h> */
-
-#include <ctype.h>		/* to declare isupper(), tolower() */
-#ifdef USE_SETMODE
-#include <fcntl.h>		/* to declare setmode()'s parameter macros */
-/* If you have setmode() but not <io.h>, just delete this line: */
-#include <io.h>			/* to declare setmode() */
-#endif
-
-#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */
-#ifdef __MWERKS__
-#include <SIOUX.h>              /* Metrowerks needs this */
-#include <console.h>		/* ... and this */
-#endif
-#ifdef THINK_C
-#include <console.h>		/* Think declares it here */
-#endif
-#endif
-
-#ifdef DONT_USE_B_MODE		/* define mode parameters for fopen() */
-#define READ_BINARY	"r"
-#else
-#ifdef VMS			/* VMS is very nonstandard */
-#define READ_BINARY	"rb", "ctx=stm"
-#else				/* standard ANSI-compliant case */
-#define READ_BINARY	"rb"
-#endif
-#endif
-
-#ifndef EXIT_FAILURE		/* define exit() codes if not provided */
-#define EXIT_FAILURE  1
-#endif
-#ifndef EXIT_SUCCESS
-#ifdef VMS
-#define EXIT_SUCCESS  1		/* VMS is very nonstandard */
-#else
-#define EXIT_SUCCESS  0
-#endif
-#endif
-
-
-/*
- * These macros are used to read the input file.
- * To reuse this code in another application, you might need to change these.
- */
-
-static FILE * infile;		/* input JPEG file */
-
-/* Return next input byte, or EOF if no more */
-#define NEXTBYTE()  getc(infile)
-
-
-/* Error exit handler */
-#define ERREXIT(msg)  (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE))
-
-
-/* Read one byte, testing for EOF */
-static int
-read_1_byte (void)
-{
-  int c;
-
-  c = NEXTBYTE();
-  if (c == EOF)
-    ERREXIT("Premature EOF in JPEG file");
-  return c;
-}
-
-/* Read 2 bytes, convert to unsigned int */
-/* All 2-byte quantities in JPEG markers are MSB first */
-static unsigned int
-read_2_bytes (void)
-{
-  int c1, c2;
-
-  c1 = NEXTBYTE();
-  if (c1 == EOF)
-    ERREXIT("Premature EOF in JPEG file");
-  c2 = NEXTBYTE();
-  if (c2 == EOF)
-    ERREXIT("Premature EOF in JPEG file");
-  return (((unsigned int) c1) << 8) + ((unsigned int) c2);
-}
-
-
-/*
- * JPEG markers consist of one or more 0xFF bytes, followed by a marker
- * code byte (which is not an FF).  Here are the marker codes of interest
- * in this program.  (See jdmarker.c for a more complete list.)
- */
-
-#define M_SOF0  0xC0		/* Start Of Frame N */
-#define M_SOF1  0xC1		/* N indicates which compression process */
-#define M_SOF2  0xC2		/* Only SOF0-SOF2 are now in common use */
-#define M_SOF3  0xC3
-#define M_SOF5  0xC5		/* NB: codes C4 and CC are NOT SOF markers */
-#define M_SOF6  0xC6
-#define M_SOF7  0xC7
-#define M_SOF9  0xC9
-#define M_SOF10 0xCA
-#define M_SOF11 0xCB
-#define M_SOF13 0xCD
-#define M_SOF14 0xCE
-#define M_SOF15 0xCF
-#define M_SOI   0xD8		/* Start Of Image (beginning of datastream) */
-#define M_EOI   0xD9		/* End Of Image (end of datastream) */
-#define M_SOS   0xDA		/* Start Of Scan (begins compressed data) */
-#define M_APP0	0xE0		/* Application-specific marker, type N */
-#define M_APP12	0xEC		/* (we don't bother to list all 16 APPn's) */
-#define M_COM   0xFE		/* COMment */
-
-
-/*
- * Find the next JPEG marker and return its marker code.
- * We expect at least one FF byte, possibly more if the compressor used FFs
- * to pad the file.
- * There could also be non-FF garbage between markers.  The treatment of such
- * garbage is unspecified; we choose to skip over it but emit a warning msg.
- * NB: this routine must not be used after seeing SOS marker, since it will
- * not deal correctly with FF/00 sequences in the compressed image data...
- */
-
-static int
-next_marker (void)
-{
-  int c;
-  int discarded_bytes = 0;
-
-  /* Find 0xFF byte; count and skip any non-FFs. */
-  c = read_1_byte();
-  while (c != 0xFF) {
-    discarded_bytes++;
-    c = read_1_byte();
-  }
-  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs
-   * are legal as pad bytes, so don't count them in discarded_bytes.
-   */
-  do {
-    c = read_1_byte();
-  } while (c == 0xFF);
-
-  if (discarded_bytes != 0) {
-    fprintf(stderr, "Warning: garbage data found in JPEG file\n");
-  }
-
-  return c;
-}
-
-
-/*
- * Read the initial marker, which should be SOI.
- * For a JFIF file, the first two bytes of the file should be literally
- * 0xFF M_SOI.  To be more general, we could use next_marker, but if the
- * input file weren't actually JPEG at all, next_marker might read the whole
- * file and then return a misleading error message...
- */
-
-static int
-first_marker (void)
-{
-  int c1, c2;
-
-  c1 = NEXTBYTE();
-  c2 = NEXTBYTE();
-  if (c1 != 0xFF || c2 != M_SOI)
-    ERREXIT("Not a JPEG file");
-  return c2;
-}
-
-
-/*
- * Most types of marker are followed by a variable-length parameter segment.
- * This routine skips over the parameters for any marker we don't otherwise
- * want to process.
- * Note that we MUST skip the parameter segment explicitly in order not to
- * be fooled by 0xFF bytes that might appear within the parameter segment;
- * such bytes do NOT introduce new markers.
- */
-
-static void
-skip_variable (void)
-/* Skip over an unknown or uninteresting variable-length marker */
-{
-  unsigned int length;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2)
-    ERREXIT("Erroneous JPEG marker length");
-  length -= 2;
-  /* Skip over the remaining bytes */
-  while (length > 0) {
-    (void) read_1_byte();
-    length--;
-  }
-}
-
-
-/*
- * Process a COM marker.
- * We want to print out the marker contents as legible text;
- * we must guard against non-text junk and varying newline representations.
- */
-
-static void
-process_COM (void)
-{
-  unsigned int length;
-  int ch;
-  int lastch = 0;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2)
-    ERREXIT("Erroneous JPEG marker length");
-  length -= 2;
-
-  while (length > 0) {
-    ch = read_1_byte();
-    /* Emit the character in a readable form.
-     * Nonprintables are converted to \nnn form,
-     * while \ is converted to \\.
-     * Newlines in CR, CR/LF, or LF form will be printed as one newline.
-     */
-    if (ch == '\r') {
-      printf("\n");
-    } else if (ch == '\n') {
-      if (lastch != '\r')
-	printf("\n");
-    } else if (ch == '\\') {
-      printf("\\\\");
-    } else if (isprint(ch)) {
-      putc(ch, stdout);
-    } else {
-      printf("\\%03o", ch);
-    }
-    lastch = ch;
-    length--;
-  }
-  printf("\n");
-}
-
-
-/*
- * Process a SOFn marker.
- * This code is only needed if you want to know the image dimensions...
- */
-
-static void
-process_SOFn (int marker)
-{
-  unsigned int length;
-  unsigned int image_height, image_width;
-  int data_precision, num_components;
-  const char * process;
-  int ci;
-
-  length = read_2_bytes();	/* usual parameter length count */
-
-  data_precision = read_1_byte();
-  image_height = read_2_bytes();
-  image_width = read_2_bytes();
-  num_components = read_1_byte();
-
-  switch (marker) {
-  case M_SOF0:	process = "Baseline";  break;
-  case M_SOF1:	process = "Extended sequential";  break;
-  case M_SOF2:	process = "Progressive";  break;
-  case M_SOF3:	process = "Lossless";  break;
-  case M_SOF5:	process = "Differential sequential";  break;
-  case M_SOF6:	process = "Differential progressive";  break;
-  case M_SOF7:	process = "Differential lossless";  break;
-  case M_SOF9:	process = "Extended sequential, arithmetic coding";  break;
-  case M_SOF10:	process = "Progressive, arithmetic coding";  break;
-  case M_SOF11:	process = "Lossless, arithmetic coding";  break;
-  case M_SOF13:	process = "Differential sequential, arithmetic coding";  break;
-  case M_SOF14:	process = "Differential progressive, arithmetic coding"; break;
-  case M_SOF15:	process = "Differential lossless, arithmetic coding";  break;
-  default:	process = "Unknown";  break;
-  }
-
-  printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",
-	 image_width, image_height, num_components, data_precision);
-  printf("JPEG process: %s\n", process);
-
-  if (length != (unsigned int) (8 + num_components * 3))
-    ERREXIT("Bogus SOF marker length");
-
-  for (ci = 0; ci < num_components; ci++) {
-    (void) read_1_byte();	/* Component ID code */
-    (void) read_1_byte();	/* H, V sampling factors */
-    (void) read_1_byte();	/* Quantization table number */
-  }
-}
-
-
-/*
- * Parse the marker stream until SOS or EOI is seen;
- * display any COM markers.
- * While the companion program wrjpgcom will always insert COM markers before
- * SOFn, other implementations might not, so we scan to SOS before stopping.
- * If we were only interested in the image dimensions, we would stop at SOFn.
- * (Conversely, if we only cared about COM markers, there would be no need
- * for special code to handle SOFn; we could treat it like other markers.)
- */
-
-static int
-scan_JPEG_header (int verbose)
-{
-  int marker;
-
-  /* Expect SOI at start of file */
-  if (first_marker() != M_SOI)
-    ERREXIT("Expected SOI marker first");
-
-  /* Scan miscellaneous markers until we reach SOS. */
-  for (;;) {
-    marker = next_marker();
-    switch (marker) {
-      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,
-       * treated as SOFn.  C4 in particular is actually DHT.
-       */
-    case M_SOF0:		/* Baseline */
-    case M_SOF1:		/* Extended sequential, Huffman */
-    case M_SOF2:		/* Progressive, Huffman */
-    case M_SOF3:		/* Lossless, Huffman */
-    case M_SOF5:		/* Differential sequential, Huffman */
-    case M_SOF6:		/* Differential progressive, Huffman */
-    case M_SOF7:		/* Differential lossless, Huffman */
-    case M_SOF9:		/* Extended sequential, arithmetic */
-    case M_SOF10:		/* Progressive, arithmetic */
-    case M_SOF11:		/* Lossless, arithmetic */
-    case M_SOF13:		/* Differential sequential, arithmetic */
-    case M_SOF14:		/* Differential progressive, arithmetic */
-    case M_SOF15:		/* Differential lossless, arithmetic */
-      if (verbose)
-	process_SOFn(marker);
-      else
-	skip_variable();
-      break;
-
-    case M_SOS:			/* stop before hitting compressed data */
-      return marker;
-
-    case M_EOI:			/* in case it's a tables-only JPEG stream */
-      return marker;
-
-    case M_COM:
-      process_COM();
-      break;
-
-    case M_APP12:
-      /* Some digital camera makers put useful textual information into
-       * APP12 markers, so we print those out too when in -verbose mode.
-       */
-      if (verbose) {
-	printf("APP12 contains:\n");
-	process_COM();
-      } else
-	skip_variable();
-      break;
-
-    default:			/* Anything else just gets skipped */
-      skip_variable();		/* we assume it has a parameter count... */
-      break;
-    }
-  } /* end loop */
-}
-
-
-/* Command line parsing code */
-
-static const char * progname;	/* program name for error messages */
-
-
-static void
-usage (void)
-/* complain about bad command line */
-{
-  fprintf(stderr, "rdjpgcom displays any textual comments in a JPEG file.\n");
-
-  fprintf(stderr, "Usage: %s [switches] [inputfile]\n", progname);
-
-  fprintf(stderr, "Switches (names may be abbreviated):\n");
-  fprintf(stderr, "  -verbose    Also display dimensions of JPEG image\n");
-
-  exit(EXIT_FAILURE);
-}
-
-
-static int
-keymatch (char * arg, const char * keyword, int minchars)
-/* Case-insensitive matching of (possibly abbreviated) keyword switches. */
-/* keyword is the constant keyword (must be lower case already), */
-/* minchars is length of minimum legal abbreviation. */
-{
-  register int ca, ck;
-  register int nmatched = 0;
-
-  while ((ca = *arg++) != '\0') {
-    if ((ck = *keyword++) == '\0')
-      return 0;			/* arg longer than keyword, no good */
-    if (isupper(ca))		/* force arg to lcase (assume ck is already) */
-      ca = tolower(ca);
-    if (ca != ck)
-      return 0;			/* no good */
-    nmatched++;			/* count matched characters */
-  }
-  /* reached end of argument; fail if it's too short for unique abbrev */
-  if (nmatched < minchars)
-    return 0;
-  return 1;			/* A-OK */
-}
-
-
-/*
- * The main program.
- */
-
-int
-main (int argc, char **argv)
-{
-  int argn;
-  char * arg;
-  int verbose = 0;
-
-  /* On Mac, fetch a command line. */
-#ifdef USE_CCOMMAND
-  argc = ccommand(&argv);
-#endif
-
-  progname = argv[0];
-  if (progname == NULL || progname[0] == 0)
-    progname = "rdjpgcom";	/* in case C library doesn't provide it */
-
-  /* Parse switches, if any */
-  for (argn = 1; argn < argc; argn++) {
-    arg = argv[argn];
-    if (arg[0] != '-')
-      break;			/* not switch, must be file name */
-    arg++;			/* advance over '-' */
-    if (keymatch(arg, "verbose", 1)) {
-      verbose++;
-    } else
-      usage();
-  }
-
-  /* Open the input file. */
-  /* Unix style: expect zero or one file name */
-  if (argn < argc-1) {
-    fprintf(stderr, "%s: only one input file\n", progname);
-    usage();
-  }
-  if (argn < argc) {
-    if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default input file is stdin */
-#ifdef USE_SETMODE		/* need to hack file mode? */
-    setmode(fileno(stdin), O_BINARY);
-#endif
-#ifdef USE_FDOPEN		/* need to re-open in binary mode? */
-    if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open stdin\n", progname);
-      exit(EXIT_FAILURE);
-    }
-#else
-    infile = stdin;
-#endif
-  }
-
-  /* Scan the JPEG headers. */
-  (void) scan_JPEG_header(verbose);
-
-  /* All done. */
-  exit(EXIT_SUCCESS);
-  return 0;			/* suppress no-return-value warnings */
-}
+/*

+ * rdjpgcom.c

+ *

+ * Copyright (C) 1994-1997, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains a very simple stand-alone application that displays

+ * the text in COM (comment) markers in a JFIF file.

+ * This may be useful as an example of the minimum logic needed to parse

+ * JPEG markers.

+ */

+

+#define JPEG_CJPEG_DJPEG	/* to get the command-line config symbols */

+#include "jinclude.h"		/* get auto-config symbols, <stdio.h> */

+

+#include <ctype.h>		/* to declare isupper(), tolower() */

+#ifdef USE_SETMODE

+#include <fcntl.h>		/* to declare setmode()'s parameter macros */

+/* If you have setmode() but not <io.h>, just delete this line: */

+#include <io.h>			/* to declare setmode() */

+#endif

+

+#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */

+#ifdef __MWERKS__

+#include <SIOUX.h>              /* Metrowerks needs this */

+#include <console.h>		/* ... and this */

+#endif

+#ifdef THINK_C

+#include <console.h>		/* Think declares it here */

+#endif

+#endif

+

+#ifdef DONT_USE_B_MODE		/* define mode parameters for fopen() */

+#define READ_BINARY	"r"

+#else

+#ifdef VMS			/* VMS is very nonstandard */

+#define READ_BINARY	"rb", "ctx=stm"

+#else				/* standard ANSI-compliant case */

+#define READ_BINARY	"rb"

+#endif

+#endif

+

+#ifndef EXIT_FAILURE		/* define exit() codes if not provided */

+#define EXIT_FAILURE  1

+#endif

+#ifndef EXIT_SUCCESS

+#ifdef VMS

+#define EXIT_SUCCESS  1		/* VMS is very nonstandard */

+#else

+#define EXIT_SUCCESS  0

+#endif

+#endif

+

+

+/*

+ * These macros are used to read the input file.

+ * To reuse this code in another application, you might need to change these.

+ */

+

+static FILE * infile;		/* input JPEG file */

+

+/* Return next input byte, or EOF if no more */

+#define NEXTBYTE()  getc(infile)

+

+

+/* Error exit handler */

+#define ERREXIT(msg)  (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE))

+

+

+/* Read one byte, testing for EOF */

+static int

+read_1_byte (void)

+{

+  int c;

+

+  c = NEXTBYTE();

+  if (c == EOF)

+    ERREXIT("Premature EOF in JPEG file");

+  return c;

+}

+

+/* Read 2 bytes, convert to unsigned int */

+/* All 2-byte quantities in JPEG markers are MSB first */

+static unsigned int

+read_2_bytes (void)

+{

+  int c1, c2;

+

+  c1 = NEXTBYTE();

+  if (c1 == EOF)

+    ERREXIT("Premature EOF in JPEG file");

+  c2 = NEXTBYTE();

+  if (c2 == EOF)

+    ERREXIT("Premature EOF in JPEG file");

+  return (((unsigned int) c1) << 8) + ((unsigned int) c2);

+}

+

+

+/*

+ * JPEG markers consist of one or more 0xFF bytes, followed by a marker

+ * code byte (which is not an FF).  Here are the marker codes of interest

+ * in this program.  (See jdmarker.c for a more complete list.)

+ */

+

+#define M_SOF0  0xC0		/* Start Of Frame N */

+#define M_SOF1  0xC1		/* N indicates which compression process */

+#define M_SOF2  0xC2		/* Only SOF0-SOF2 are now in common use */

+#define M_SOF3  0xC3

+#define M_SOF5  0xC5		/* NB: codes C4 and CC are NOT SOF markers */

+#define M_SOF6  0xC6

+#define M_SOF7  0xC7

+#define M_SOF9  0xC9

+#define M_SOF10 0xCA

+#define M_SOF11 0xCB

+#define M_SOF13 0xCD

+#define M_SOF14 0xCE

+#define M_SOF15 0xCF

+#define M_SOI   0xD8		/* Start Of Image (beginning of datastream) */

+#define M_EOI   0xD9		/* End Of Image (end of datastream) */

+#define M_SOS   0xDA		/* Start Of Scan (begins compressed data) */

+#define M_APP0	0xE0		/* Application-specific marker, type N */

+#define M_APP12	0xEC		/* (we don't bother to list all 16 APPn's) */

+#define M_COM   0xFE		/* COMment */

+

+

+/*

+ * Find the next JPEG marker and return its marker code.

+ * We expect at least one FF byte, possibly more if the compressor used FFs

+ * to pad the file.

+ * There could also be non-FF garbage between markers.  The treatment of such

+ * garbage is unspecified; we choose to skip over it but emit a warning msg.

+ * NB: this routine must not be used after seeing SOS marker, since it will

+ * not deal correctly with FF/00 sequences in the compressed image data...

+ */

+

+static int

+next_marker (void)

+{

+  int c;

+  int discarded_bytes = 0;

+

+  /* Find 0xFF byte; count and skip any non-FFs. */

+  c = read_1_byte();

+  while (c != 0xFF) {

+    discarded_bytes++;

+    c = read_1_byte();

+  }

+  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs

+   * are legal as pad bytes, so don't count them in discarded_bytes.

+   */

+  do {

+    c = read_1_byte();

+  } while (c == 0xFF);

+

+  if (discarded_bytes != 0) {

+    fprintf(stderr, "Warning: garbage data found in JPEG file\n");

+  }

+

+  return c;

+}

+

+

+/*

+ * Read the initial marker, which should be SOI.

+ * For a JFIF file, the first two bytes of the file should be literally

+ * 0xFF M_SOI.  To be more general, we could use next_marker, but if the

+ * input file weren't actually JPEG at all, next_marker might read the whole

+ * file and then return a misleading error message...

+ */

+

+static int

+first_marker (void)

+{

+  int c1, c2;

+

+  c1 = NEXTBYTE();

+  c2 = NEXTBYTE();

+  if (c1 != 0xFF || c2 != M_SOI)

+    ERREXIT("Not a JPEG file");

+  return c2;

+}

+

+

+/*

+ * Most types of marker are followed by a variable-length parameter segment.

+ * This routine skips over the parameters for any marker we don't otherwise

+ * want to process.

+ * Note that we MUST skip the parameter segment explicitly in order not to

+ * be fooled by 0xFF bytes that might appear within the parameter segment;

+ * such bytes do NOT introduce new markers.

+ */

+

+static void

+skip_variable (void)

+/* Skip over an unknown or uninteresting variable-length marker */

+{

+  unsigned int length;

+

+  /* Get the marker parameter length count */

+  length = read_2_bytes();

+  /* Length includes itself, so must be at least 2 */

+  if (length < 2)

+    ERREXIT("Erroneous JPEG marker length");

+  length -= 2;

+  /* Skip over the remaining bytes */

+  while (length > 0) {

+    (void) read_1_byte();

+    length--;

+  }

+}

+

+

+/*

+ * Process a COM marker.

+ * We want to print out the marker contents as legible text;

+ * we must guard against non-text junk and varying newline representations.

+ */

+

+static void

+process_COM (void)

+{

+  unsigned int length;

+  int ch;

+  int lastch = 0;

+

+  /* Get the marker parameter length count */

+  length = read_2_bytes();

+  /* Length includes itself, so must be at least 2 */

+  if (length < 2)

+    ERREXIT("Erroneous JPEG marker length");

+  length -= 2;

+

+  while (length > 0) {

+    ch = read_1_byte();

+    /* Emit the character in a readable form.

+     * Nonprintables are converted to \nnn form,

+     * while \ is converted to \\.

+     * Newlines in CR, CR/LF, or LF form will be printed as one newline.

+     */

+    if (ch == '\r') {

+      printf("\n");

+    } else if (ch == '\n') {

+      if (lastch != '\r')

+	printf("\n");

+    } else if (ch == '\\') {

+      printf("\\\\");

+    } else if (isprint(ch)) {

+      putc(ch, stdout);

+    } else {

+      printf("\\%03o", ch);

+    }

+    lastch = ch;

+    length--;

+  }

+  printf("\n");

+}

+

+

+/*

+ * Process a SOFn marker.

+ * This code is only needed if you want to know the image dimensions...

+ */

+

+static void

+process_SOFn (int marker)

+{

+  unsigned int length;

+  unsigned int image_height, image_width;

+  int data_precision, num_components;

+  const char * process;

+  int ci;

+

+  length = read_2_bytes();	/* usual parameter length count */

+

+  data_precision = read_1_byte();

+  image_height = read_2_bytes();

+  image_width = read_2_bytes();

+  num_components = read_1_byte();

+

+  switch (marker) {

+  case M_SOF0:	process = "Baseline";  break;

+  case M_SOF1:	process = "Extended sequential";  break;

+  case M_SOF2:	process = "Progressive";  break;

+  case M_SOF3:	process = "Lossless";  break;

+  case M_SOF5:	process = "Differential sequential";  break;

+  case M_SOF6:	process = "Differential progressive";  break;

+  case M_SOF7:	process = "Differential lossless";  break;

+  case M_SOF9:	process = "Extended sequential, arithmetic coding";  break;

+  case M_SOF10:	process = "Progressive, arithmetic coding";  break;

+  case M_SOF11:	process = "Lossless, arithmetic coding";  break;

+  case M_SOF13:	process = "Differential sequential, arithmetic coding";  break;

+  case M_SOF14:	process = "Differential progressive, arithmetic coding"; break;

+  case M_SOF15:	process = "Differential lossless, arithmetic coding";  break;

+  default:	process = "Unknown";  break;

+  }

+

+  printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",

+	 image_width, image_height, num_components, data_precision);

+  printf("JPEG process: %s\n", process);

+

+  if (length != (unsigned int) (8 + num_components * 3))

+    ERREXIT("Bogus SOF marker length");

+

+  for (ci = 0; ci < num_components; ci++) {

+    (void) read_1_byte();	/* Component ID code */

+    (void) read_1_byte();	/* H, V sampling factors */

+    (void) read_1_byte();	/* Quantization table number */

+  }

+}

+

+

+/*

+ * Parse the marker stream until SOS or EOI is seen;

+ * display any COM markers.

+ * While the companion program wrjpgcom will always insert COM markers before

+ * SOFn, other implementations might not, so we scan to SOS before stopping.

+ * If we were only interested in the image dimensions, we would stop at SOFn.

+ * (Conversely, if we only cared about COM markers, there would be no need

+ * for special code to handle SOFn; we could treat it like other markers.)

+ */

+

+static int

+scan_JPEG_header (int verbose)

+{

+  int marker;

+

+  /* Expect SOI at start of file */

+  if (first_marker() != M_SOI)

+    ERREXIT("Expected SOI marker first");

+

+  /* Scan miscellaneous markers until we reach SOS. */

+  for (;;) {

+    marker = next_marker();

+    switch (marker) {

+      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,

+       * treated as SOFn.  C4 in particular is actually DHT.

+       */

+    case M_SOF0:		/* Baseline */

+    case M_SOF1:		/* Extended sequential, Huffman */

+    case M_SOF2:		/* Progressive, Huffman */

+    case M_SOF3:		/* Lossless, Huffman */

+    case M_SOF5:		/* Differential sequential, Huffman */

+    case M_SOF6:		/* Differential progressive, Huffman */

+    case M_SOF7:		/* Differential lossless, Huffman */

+    case M_SOF9:		/* Extended sequential, arithmetic */

+    case M_SOF10:		/* Progressive, arithmetic */

+    case M_SOF11:		/* Lossless, arithmetic */

+    case M_SOF13:		/* Differential sequential, arithmetic */

+    case M_SOF14:		/* Differential progressive, arithmetic */

+    case M_SOF15:		/* Differential lossless, arithmetic */

+      if (verbose)

+	process_SOFn(marker);

+      else

+	skip_variable();

+      break;

+

+    case M_SOS:			/* stop before hitting compressed data */

+      return marker;

+

+    case M_EOI:			/* in case it's a tables-only JPEG stream */

+      return marker;

+

+    case M_COM:

+      process_COM();

+      break;

+

+    case M_APP12:

+      /* Some digital camera makers put useful textual information into

+       * APP12 markers, so we print those out too when in -verbose mode.

+       */

+      if (verbose) {

+	printf("APP12 contains:\n");

+	process_COM();

+      } else

+	skip_variable();

+      break;

+

+    default:			/* Anything else just gets skipped */

+      skip_variable();		/* we assume it has a parameter count... */

+      break;

+    }

+  } /* end loop */

+}

+

+

+/* Command line parsing code */

+

+static const char * progname;	/* program name for error messages */

+

+

+static void

+usage (void)

+/* complain about bad command line */

+{

+  fprintf(stderr, "rdjpgcom displays any textual comments in a JPEG file.\n");

+

+  fprintf(stderr, "Usage: %s [switches] [inputfile]\n", progname);

+

+  fprintf(stderr, "Switches (names may be abbreviated):\n");

+  fprintf(stderr, "  -verbose    Also display dimensions of JPEG image\n");

+

+  exit(EXIT_FAILURE);

+}

+

+

+static int

+keymatch (char * arg, const char * keyword, int minchars)

+/* Case-insensitive matching of (possibly abbreviated) keyword switches. */

+/* keyword is the constant keyword (must be lower case already), */

+/* minchars is length of minimum legal abbreviation. */

+{

+  register int ca, ck;

+  register int nmatched = 0;

+

+  while ((ca = *arg++) != '\0') {

+    if ((ck = *keyword++) == '\0')

+      return 0;			/* arg longer than keyword, no good */

+    if (isupper(ca))		/* force arg to lcase (assume ck is already) */

+      ca = tolower(ca);

+    if (ca != ck)

+      return 0;			/* no good */

+    nmatched++;			/* count matched characters */

+  }

+  /* reached end of argument; fail if it's too short for unique abbrev */

+  if (nmatched < minchars)

+    return 0;

+  return 1;			/* A-OK */

+}

+

+

+/*

+ * The main program.

+ */

+

+int

+main (int argc, char **argv)

+{

+  int argn;

+  char * arg;

+  int verbose = 0;

+

+  /* On Mac, fetch a command line. */

+#ifdef USE_CCOMMAND

+  argc = ccommand(&argv);

+#endif

+

+  progname = argv[0];

+  if (progname == NULL || progname[0] == 0)

+    progname = "rdjpgcom";	/* in case C library doesn't provide it */

+

+  /* Parse switches, if any */

+  for (argn = 1; argn < argc; argn++) {

+    arg = argv[argn];

+    if (arg[0] != '-')

+      break;			/* not switch, must be file name */

+    arg++;			/* advance over '-' */

+    if (keymatch(arg, "verbose", 1)) {

+      verbose++;

+    } else

+      usage();

+  }

+

+  /* Open the input file. */

+  /* Unix style: expect zero or one file name */

+  if (argn < argc-1) {

+    fprintf(stderr, "%s: only one input file\n", progname);

+    usage();

+  }

+  if (argn < argc) {

+    if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default input file is stdin */

+#ifdef USE_SETMODE		/* need to hack file mode? */

+    setmode(fileno(stdin), O_BINARY);

+#endif

+#ifdef USE_FDOPEN		/* need to re-open in binary mode? */

+    if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open stdin\n", progname);

+      exit(EXIT_FAILURE);

+    }

+#else

+    infile = stdin;

+#endif

+  }

+

+  /* Scan the JPEG headers. */

+  (void) scan_JPEG_header(verbose);

+

+  /* All done. */

+  exit(EXIT_SUCCESS);

+  return 0;			/* suppress no-return-value warnings */

+}

diff --git a/test/monniaux/jpeg-6b/rdswitch.c b/test/monniaux/jpeg-6b/rdswitch.c
index 4f4bb4f5..b915ad9d 100644
--- a/test/monniaux/jpeg-6b/rdswitch.c
+++ b/test/monniaux/jpeg-6b/rdswitch.c
@@ -1,332 +1,332 @@
-/*
- * rdswitch.c
- *
- * Copyright (C) 1991-1996, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains routines to process some of cjpeg's more complicated
- * command-line switches.  Switches processed here are:
- *	-qtables file		Read quantization tables from text file
- *	-scans file		Read scan script from text file
- *	-qslots N[,N,...]	Set component quantization table selectors
- *	-sample HxV[,HxV,...]	Set component sampling factors
- */
-
-#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */
-#include <ctype.h>		/* to declare isdigit(), isspace() */
-
-
-LOCAL(int)
-text_getc (FILE * file)
-/* Read next char, skipping over any comments (# to end of line) */
-/* A comment/newline sequence is returned as a newline */
-{
-  register int ch;
-  
-  ch = getc(file);
-  if (ch == '#') {
-    do {
-      ch = getc(file);
-    } while (ch != '\n' && ch != EOF);
-  }
-  return ch;
-}
-
-
-LOCAL(boolean)
-read_text_integer (FILE * file, long * result, int * termchar)
-/* Read an unsigned decimal integer from a file, store it in result */
-/* Reads one trailing character after the integer; returns it in termchar */
-{
-  register int ch;
-  register long val;
-  
-  /* Skip any leading whitespace, detect EOF */
-  do {
-    ch = text_getc(file);
-    if (ch == EOF) {
-      *termchar = ch;
-      return FALSE;
-    }
-  } while (isspace(ch));
-  
-  if (! isdigit(ch)) {
-    *termchar = ch;
-    return FALSE;
-  }
-
-  val = ch - '0';
-  while ((ch = text_getc(file)) != EOF) {
-    if (! isdigit(ch))
-      break;
-    val *= 10;
-    val += ch - '0';
-  }
-  *result = val;
-  *termchar = ch;
-  return TRUE;
-}
-
-
-GLOBAL(boolean)
-read_quant_tables (j_compress_ptr cinfo, char * filename,
-		   int scale_factor, boolean force_baseline)
-/* Read a set of quantization tables from the specified file.
- * The file is plain ASCII text: decimal numbers with whitespace between.
- * Comments preceded by '#' may be included in the file.
- * There may be one to NUM_QUANT_TBLS tables in the file, each of 64 values.
- * The tables are implicitly numbered 0,1,etc.
- * NOTE: does not affect the qslots mapping, which will default to selecting
- * table 0 for luminance (or primary) components, 1 for chrominance components.
- * You must use -qslots if you want a different component->table mapping.
- */
-{
-  FILE * fp;
-  int tblno, i, termchar;
-  long val;
-  unsigned int table[DCTSIZE2];
-
-  if ((fp = fopen(filename, "r")) == NULL) {
-    fprintf(stderr, "Can't open table file %s\n", filename);
-    return FALSE;
-  }
-  tblno = 0;
-
-  while (read_text_integer(fp, &val, &termchar)) { /* read 1st element of table */
-    if (tblno >= NUM_QUANT_TBLS) {
-      fprintf(stderr, "Too many tables in file %s\n", filename);
-      fclose(fp);
-      return FALSE;
-    }
-    table[0] = (unsigned int) val;
-    for (i = 1; i < DCTSIZE2; i++) {
-      if (! read_text_integer(fp, &val, &termchar)) {
-	fprintf(stderr, "Invalid table data in file %s\n", filename);
-	fclose(fp);
-	return FALSE;
-      }
-      table[i] = (unsigned int) val;
-    }
-    jpeg_add_quant_table(cinfo, tblno, table, scale_factor, force_baseline);
-    tblno++;
-  }
-
-  if (termchar != EOF) {
-    fprintf(stderr, "Non-numeric data in file %s\n", filename);
-    fclose(fp);
-    return FALSE;
-  }
-
-  fclose(fp);
-  return TRUE;
-}
-
-
-#ifdef C_MULTISCAN_FILES_SUPPORTED
-
-LOCAL(boolean)
-read_scan_integer (FILE * file, long * result, int * termchar)
-/* Variant of read_text_integer that always looks for a non-space termchar;
- * this simplifies parsing of punctuation in scan scripts.
- */
-{
-  register int ch;
-
-  if (! read_text_integer(file, result, termchar))
-    return FALSE;
-  ch = *termchar;
-  while (ch != EOF && isspace(ch))
-    ch = text_getc(file);
-  if (isdigit(ch)) {		/* oops, put it back */
-    if (ungetc(ch, file) == EOF)
-      return FALSE;
-    ch = ' ';
-  } else {
-    /* Any separators other than ';' and ':' are ignored;
-     * this allows user to insert commas, etc, if desired.
-     */
-    if (ch != EOF && ch != ';' && ch != ':')
-      ch = ' ';
-  }
-  *termchar = ch;
-  return TRUE;
-}
-
-
-GLOBAL(boolean)
-read_scan_script (j_compress_ptr cinfo, char * filename)
-/* Read a scan script from the specified text file.
- * Each entry in the file defines one scan to be emitted.
- * Entries are separated by semicolons ';'.
- * An entry contains one to four component indexes,
- * optionally followed by a colon ':' and four progressive-JPEG parameters.
- * The component indexes denote which component(s) are to be transmitted
- * in the current scan.  The first component has index 0.
- * Sequential JPEG is used if the progressive-JPEG parameters are omitted.
- * The file is free format text: any whitespace may appear between numbers
- * and the ':' and ';' punctuation marks.  Also, other punctuation (such
- * as commas or dashes) can be placed between numbers if desired.
- * Comments preceded by '#' may be included in the file.
- * Note: we do very little validity checking here;
- * jcmaster.c will validate the script parameters.
- */
-{
-  FILE * fp;
-  int scanno, ncomps, termchar;
-  long val;
-  jpeg_scan_info * scanptr;
-#define MAX_SCANS  100		/* quite arbitrary limit */
-  jpeg_scan_info scans[MAX_SCANS];
-
-  if ((fp = fopen(filename, "r")) == NULL) {
-    fprintf(stderr, "Can't open scan definition file %s\n", filename);
-    return FALSE;
-  }
-  scanptr = scans;
-  scanno = 0;
-
-  while (read_scan_integer(fp, &val, &termchar)) {
-    if (scanno >= MAX_SCANS) {
-      fprintf(stderr, "Too many scans defined in file %s\n", filename);
-      fclose(fp);
-      return FALSE;
-    }
-    scanptr->component_index[0] = (int) val;
-    ncomps = 1;
-    while (termchar == ' ') {
-      if (ncomps >= MAX_COMPS_IN_SCAN) {
-	fprintf(stderr, "Too many components in one scan in file %s\n",
-		filename);
-	fclose(fp);
-	return FALSE;
-      }
-      if (! read_scan_integer(fp, &val, &termchar))
-	goto bogus;
-      scanptr->component_index[ncomps] = (int) val;
-      ncomps++;
-    }
-    scanptr->comps_in_scan = ncomps;
-    if (termchar == ':') {
-      if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')
-	goto bogus;
-      scanptr->Ss = (int) val;
-      if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')
-	goto bogus;
-      scanptr->Se = (int) val;
-      if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')
-	goto bogus;
-      scanptr->Ah = (int) val;
-      if (! read_scan_integer(fp, &val, &termchar))
-	goto bogus;
-      scanptr->Al = (int) val;
-    } else {
-      /* set non-progressive parameters */
-      scanptr->Ss = 0;
-      scanptr->Se = DCTSIZE2-1;
-      scanptr->Ah = 0;
-      scanptr->Al = 0;
-    }
-    if (termchar != ';' && termchar != EOF) {
-bogus:
-      fprintf(stderr, "Invalid scan entry format in file %s\n", filename);
-      fclose(fp);
-      return FALSE;
-    }
-    scanptr++, scanno++;
-  }
-
-  if (termchar != EOF) {
-    fprintf(stderr, "Non-numeric data in file %s\n", filename);
-    fclose(fp);
-    return FALSE;
-  }
-
-  if (scanno > 0) {
-    /* Stash completed scan list in cinfo structure.
-     * NOTE: for cjpeg's use, JPOOL_IMAGE is the right lifetime for this data,
-     * but if you want to compress multiple images you'd want JPOOL_PERMANENT.
-     */
-    scanptr = (jpeg_scan_info *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				  scanno * SIZEOF(jpeg_scan_info));
-    MEMCOPY(scanptr, scans, scanno * SIZEOF(jpeg_scan_info));
-    cinfo->scan_info = scanptr;
-    cinfo->num_scans = scanno;
-  }
-
-  fclose(fp);
-  return TRUE;
-}
-
-#endif /* C_MULTISCAN_FILES_SUPPORTED */
-
-
-GLOBAL(boolean)
-set_quant_slots (j_compress_ptr cinfo, char *arg)
-/* Process a quantization-table-selectors parameter string, of the form
- *     N[,N,...]
- * If there are more components than parameters, the last value is replicated.
- */
-{
-  int val = 0;			/* default table # */
-  int ci;
-  char ch;
-
-  for (ci = 0; ci < MAX_COMPONENTS; ci++) {
-    if (*arg) {
-      ch = ',';			/* if not set by sscanf, will be ',' */
-      if (sscanf(arg, "%d%c", &val, &ch) < 1)
-	return FALSE;
-      if (ch != ',')		/* syntax check */
-	return FALSE;
-      if (val < 0 || val >= NUM_QUANT_TBLS) {
-	fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n",
-		NUM_QUANT_TBLS-1);
-	return FALSE;
-      }
-      cinfo->comp_info[ci].quant_tbl_no = val;
-      while (*arg && *arg++ != ',') /* advance to next segment of arg string */
-	;
-    } else {
-      /* reached end of parameter, set remaining components to last table */
-      cinfo->comp_info[ci].quant_tbl_no = val;
-    }
-  }
-  return TRUE;
-}
-
-
-GLOBAL(boolean)
-set_sample_factors (j_compress_ptr cinfo, char *arg)
-/* Process a sample-factors parameter string, of the form
- *     HxV[,HxV,...]
- * If there are more components than parameters, "1x1" is assumed for the rest.
- */
-{
-  int ci, val1, val2;
-  char ch1, ch2;
-
-  for (ci = 0; ci < MAX_COMPONENTS; ci++) {
-    if (*arg) {
-      ch2 = ',';		/* if not set by sscanf, will be ',' */
-      if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3)
-	return FALSE;
-      if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */
-	return FALSE;
-      if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) {
-	fprintf(stderr, "JPEG sampling factors must be 1..4\n");
-	return FALSE;
-      }
-      cinfo->comp_info[ci].h_samp_factor = val1;
-      cinfo->comp_info[ci].v_samp_factor = val2;
-      while (*arg && *arg++ != ',') /* advance to next segment of arg string */
-	;
-    } else {
-      /* reached end of parameter, set remaining components to 1x1 sampling */
-      cinfo->comp_info[ci].h_samp_factor = 1;
-      cinfo->comp_info[ci].v_samp_factor = 1;
-    }
-  }
-  return TRUE;
-}
+/*

+ * rdswitch.c

+ *

+ * Copyright (C) 1991-1996, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains routines to process some of cjpeg's more complicated

+ * command-line switches.  Switches processed here are:

+ *	-qtables file		Read quantization tables from text file

+ *	-scans file		Read scan script from text file

+ *	-qslots N[,N,...]	Set component quantization table selectors

+ *	-sample HxV[,HxV,...]	Set component sampling factors

+ */

+

+#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */

+#include <ctype.h>		/* to declare isdigit(), isspace() */

+

+

+LOCAL(int)

+text_getc (FILE * file)

+/* Read next char, skipping over any comments (# to end of line) */

+/* A comment/newline sequence is returned as a newline */

+{

+  register int ch;

+  

+  ch = getc(file);

+  if (ch == '#') {

+    do {

+      ch = getc(file);

+    } while (ch != '\n' && ch != EOF);

+  }

+  return ch;

+}

+

+

+LOCAL(boolean)

+read_text_integer (FILE * file, long * result, int * termchar)

+/* Read an unsigned decimal integer from a file, store it in result */

+/* Reads one trailing character after the integer; returns it in termchar */

+{

+  register int ch;

+  register long val;

+  

+  /* Skip any leading whitespace, detect EOF */

+  do {

+    ch = text_getc(file);

+    if (ch == EOF) {

+      *termchar = ch;

+      return FALSE;

+    }

+  } while (isspace(ch));

+  

+  if (! isdigit(ch)) {

+    *termchar = ch;

+    return FALSE;

+  }

+

+  val = ch - '0';

+  while ((ch = text_getc(file)) != EOF) {

+    if (! isdigit(ch))

+      break;

+    val *= 10;

+    val += ch - '0';

+  }

+  *result = val;

+  *termchar = ch;

+  return TRUE;

+}

+

+

+GLOBAL(boolean)

+read_quant_tables (j_compress_ptr cinfo, char * filename,

+		   int scale_factor, boolean force_baseline)

+/* Read a set of quantization tables from the specified file.

+ * The file is plain ASCII text: decimal numbers with whitespace between.

+ * Comments preceded by '#' may be included in the file.

+ * There may be one to NUM_QUANT_TBLS tables in the file, each of 64 values.

+ * The tables are implicitly numbered 0,1,etc.

+ * NOTE: does not affect the qslots mapping, which will default to selecting

+ * table 0 for luminance (or primary) components, 1 for chrominance components.

+ * You must use -qslots if you want a different component->table mapping.

+ */

+{

+  FILE * fp;

+  int tblno, i, termchar;

+  long val;

+  unsigned int table[DCTSIZE2];

+

+  if ((fp = fopen(filename, "r")) == NULL) {

+    fprintf(stderr, "Can't open table file %s\n", filename);

+    return FALSE;

+  }

+  tblno = 0;

+

+  while (read_text_integer(fp, &val, &termchar)) { /* read 1st element of table */

+    if (tblno >= NUM_QUANT_TBLS) {

+      fprintf(stderr, "Too many tables in file %s\n", filename);

+      fclose(fp);

+      return FALSE;

+    }

+    table[0] = (unsigned int) val;

+    for (i = 1; i < DCTSIZE2; i++) {

+      if (! read_text_integer(fp, &val, &termchar)) {

+	fprintf(stderr, "Invalid table data in file %s\n", filename);

+	fclose(fp);

+	return FALSE;

+      }

+      table[i] = (unsigned int) val;

+    }

+    jpeg_add_quant_table(cinfo, tblno, table, scale_factor, force_baseline);

+    tblno++;

+  }

+

+  if (termchar != EOF) {

+    fprintf(stderr, "Non-numeric data in file %s\n", filename);

+    fclose(fp);

+    return FALSE;

+  }

+

+  fclose(fp);

+  return TRUE;

+}

+

+

+#ifdef C_MULTISCAN_FILES_SUPPORTED

+

+LOCAL(boolean)

+read_scan_integer (FILE * file, long * result, int * termchar)

+/* Variant of read_text_integer that always looks for a non-space termchar;

+ * this simplifies parsing of punctuation in scan scripts.

+ */

+{

+  register int ch;

+

+  if (! read_text_integer(file, result, termchar))

+    return FALSE;

+  ch = *termchar;

+  while (ch != EOF && isspace(ch))

+    ch = text_getc(file);

+  if (isdigit(ch)) {		/* oops, put it back */

+    if (ungetc(ch, file) == EOF)

+      return FALSE;

+    ch = ' ';

+  } else {

+    /* Any separators other than ';' and ':' are ignored;

+     * this allows user to insert commas, etc, if desired.

+     */

+    if (ch != EOF && ch != ';' && ch != ':')

+      ch = ' ';

+  }

+  *termchar = ch;

+  return TRUE;

+}

+

+

+GLOBAL(boolean)

+read_scan_script (j_compress_ptr cinfo, char * filename)

+/* Read a scan script from the specified text file.

+ * Each entry in the file defines one scan to be emitted.

+ * Entries are separated by semicolons ';'.

+ * An entry contains one to four component indexes,

+ * optionally followed by a colon ':' and four progressive-JPEG parameters.

+ * The component indexes denote which component(s) are to be transmitted

+ * in the current scan.  The first component has index 0.

+ * Sequential JPEG is used if the progressive-JPEG parameters are omitted.

+ * The file is free format text: any whitespace may appear between numbers

+ * and the ':' and ';' punctuation marks.  Also, other punctuation (such

+ * as commas or dashes) can be placed between numbers if desired.

+ * Comments preceded by '#' may be included in the file.

+ * Note: we do very little validity checking here;

+ * jcmaster.c will validate the script parameters.

+ */

+{

+  FILE * fp;

+  int scanno, ncomps, termchar;

+  long val;

+  jpeg_scan_info * scanptr;

+#define MAX_SCANS  100		/* quite arbitrary limit */

+  jpeg_scan_info scans[MAX_SCANS];

+

+  if ((fp = fopen(filename, "r")) == NULL) {

+    fprintf(stderr, "Can't open scan definition file %s\n", filename);

+    return FALSE;

+  }

+  scanptr = scans;

+  scanno = 0;

+

+  while (read_scan_integer(fp, &val, &termchar)) {

+    if (scanno >= MAX_SCANS) {

+      fprintf(stderr, "Too many scans defined in file %s\n", filename);

+      fclose(fp);

+      return FALSE;

+    }

+    scanptr->component_index[0] = (int) val;

+    ncomps = 1;

+    while (termchar == ' ') {

+      if (ncomps >= MAX_COMPS_IN_SCAN) {

+	fprintf(stderr, "Too many components in one scan in file %s\n",

+		filename);

+	fclose(fp);

+	return FALSE;

+      }

+      if (! read_scan_integer(fp, &val, &termchar))

+	goto bogus;

+      scanptr->component_index[ncomps] = (int) val;

+      ncomps++;

+    }

+    scanptr->comps_in_scan = ncomps;

+    if (termchar == ':') {

+      if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')

+	goto bogus;

+      scanptr->Ss = (int) val;

+      if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')

+	goto bogus;

+      scanptr->Se = (int) val;

+      if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')

+	goto bogus;

+      scanptr->Ah = (int) val;

+      if (! read_scan_integer(fp, &val, &termchar))

+	goto bogus;

+      scanptr->Al = (int) val;

+    } else {

+      /* set non-progressive parameters */

+      scanptr->Ss = 0;

+      scanptr->Se = DCTSIZE2-1;

+      scanptr->Ah = 0;

+      scanptr->Al = 0;

+    }

+    if (termchar != ';' && termchar != EOF) {

+bogus:

+      fprintf(stderr, "Invalid scan entry format in file %s\n", filename);

+      fclose(fp);

+      return FALSE;

+    }

+    scanptr++, scanno++;

+  }

+

+  if (termchar != EOF) {

+    fprintf(stderr, "Non-numeric data in file %s\n", filename);

+    fclose(fp);

+    return FALSE;

+  }

+

+  if (scanno > 0) {

+    /* Stash completed scan list in cinfo structure.

+     * NOTE: for cjpeg's use, JPOOL_IMAGE is the right lifetime for this data,

+     * but if you want to compress multiple images you'd want JPOOL_PERMANENT.

+     */

+    scanptr = (jpeg_scan_info *)

+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,

+				  scanno * SIZEOF(jpeg_scan_info));

+    MEMCOPY(scanptr, scans, scanno * SIZEOF(jpeg_scan_info));

+    cinfo->scan_info = scanptr;

+    cinfo->num_scans = scanno;

+  }

+

+  fclose(fp);

+  return TRUE;

+}

+

+#endif /* C_MULTISCAN_FILES_SUPPORTED */

+

+

+GLOBAL(boolean)

+set_quant_slots (j_compress_ptr cinfo, char *arg)

+/* Process a quantization-table-selectors parameter string, of the form

+ *     N[,N,...]

+ * If there are more components than parameters, the last value is replicated.

+ */

+{

+  int val = 0;			/* default table # */

+  int ci;

+  char ch;

+

+  for (ci = 0; ci < MAX_COMPONENTS; ci++) {

+    if (*arg) {

+      ch = ',';			/* if not set by sscanf, will be ',' */

+      if (sscanf(arg, "%d%c", &val, &ch) < 1)

+	return FALSE;

+      if (ch != ',')		/* syntax check */

+	return FALSE;

+      if (val < 0 || val >= NUM_QUANT_TBLS) {

+	fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n",

+		NUM_QUANT_TBLS-1);

+	return FALSE;

+      }

+      cinfo->comp_info[ci].quant_tbl_no = val;

+      while (*arg && *arg++ != ',') /* advance to next segment of arg string */

+	;

+    } else {

+      /* reached end of parameter, set remaining components to last table */

+      cinfo->comp_info[ci].quant_tbl_no = val;

+    }

+  }

+  return TRUE;

+}

+

+

+GLOBAL(boolean)

+set_sample_factors (j_compress_ptr cinfo, char *arg)

+/* Process a sample-factors parameter string, of the form

+ *     HxV[,HxV,...]

+ * If there are more components than parameters, "1x1" is assumed for the rest.

+ */

+{

+  int ci, val1, val2;

+  char ch1, ch2;

+

+  for (ci = 0; ci < MAX_COMPONENTS; ci++) {

+    if (*arg) {

+      ch2 = ',';		/* if not set by sscanf, will be ',' */

+      if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3)

+	return FALSE;

+      if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */

+	return FALSE;

+      if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) {

+	fprintf(stderr, "JPEG sampling factors must be 1..4\n");

+	return FALSE;

+      }

+      cinfo->comp_info[ci].h_samp_factor = val1;

+      cinfo->comp_info[ci].v_samp_factor = val2;

+      while (*arg && *arg++ != ',') /* advance to next segment of arg string */

+	;

+    } else {

+      /* reached end of parameter, set remaining components to 1x1 sampling */

+      cinfo->comp_info[ci].h_samp_factor = 1;

+      cinfo->comp_info[ci].v_samp_factor = 1;

+    }

+  }

+  return TRUE;

+}

diff --git a/test/monniaux/jpeg-6b/wrgif.c b/test/monniaux/jpeg-6b/wrgif.c
index 5fe83283..6d3eaf39 100644
--- a/test/monniaux/jpeg-6b/wrgif.c
+++ b/test/monniaux/jpeg-6b/wrgif.c
@@ -271,7 +271,7 @@ emit_header (gif_dest_ptr dinfo, int num_colors, JSAMPARRAY colormap)
 	}
       } else {
 	/* Create a gray-scale map of num_colors values, range 0..255 */
-	put_3bytes(dinfo, (i * 255 + (num_colors-1)/2) / (num_colors-1));
+	put_3bytes(dinfo, INT_DIV((i * 255 + (num_colors-1)/2), (num_colors-1)));
       }
     } else {
       /* fill out the map to a power of 2 */
@@ -349,6 +349,7 @@ finish_output_gif (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
   fflush(dest->pub.output_file);
   if (ferror(dest->pub.output_file))
     ERREXIT(cinfo, JERR_FILE_WRITE);
+  KILL_TAIL_CALL();
 }
 
 
diff --git a/test/monniaux/jpeg-6b/wrjpgcom.c b/test/monniaux/jpeg-6b/wrjpgcom.c
index 8c04b055..7d10ee66 100644
--- a/test/monniaux/jpeg-6b/wrjpgcom.c
+++ b/test/monniaux/jpeg-6b/wrjpgcom.c
@@ -1,583 +1,583 @@
-/*
- * wrjpgcom.c
- *
- * Copyright (C) 1994-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
- *
- * This file contains a very simple stand-alone application that inserts
- * user-supplied text as a COM (comment) marker in a JFIF file.
- * This may be useful as an example of the minimum logic needed to parse
- * JPEG markers.
- */
-
-#define JPEG_CJPEG_DJPEG	/* to get the command-line config symbols */
-#include "jinclude.h"		/* get auto-config symbols, <stdio.h> */
-
-#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare malloc() */
-extern void * malloc ();
-#endif
-#include <ctype.h>		/* to declare isupper(), tolower() */
-#ifdef USE_SETMODE
-#include <fcntl.h>		/* to declare setmode()'s parameter macros */
-/* If you have setmode() but not <io.h>, just delete this line: */
-#include <io.h>			/* to declare setmode() */
-#endif
-
-#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */
-#ifdef __MWERKS__
-#include <SIOUX.h>              /* Metrowerks needs this */
-#include <console.h>		/* ... and this */
-#endif
-#ifdef THINK_C
-#include <console.h>		/* Think declares it here */
-#endif
-#endif
-
-#ifdef DONT_USE_B_MODE		/* define mode parameters for fopen() */
-#define READ_BINARY	"r"
-#define WRITE_BINARY	"w"
-#else
-#ifdef VMS			/* VMS is very nonstandard */
-#define READ_BINARY	"rb", "ctx=stm"
-#define WRITE_BINARY	"wb", "ctx=stm"
-#else				/* standard ANSI-compliant case */
-#define READ_BINARY	"rb"
-#define WRITE_BINARY	"wb"
-#endif
-#endif
-
-#ifndef EXIT_FAILURE		/* define exit() codes if not provided */
-#define EXIT_FAILURE  1
-#endif
-#ifndef EXIT_SUCCESS
-#ifdef VMS
-#define EXIT_SUCCESS  1		/* VMS is very nonstandard */
-#else
-#define EXIT_SUCCESS  0
-#endif
-#endif
-
-/* Reduce this value if your malloc() can't allocate blocks up to 64K.
- * On DOS, compiling in large model is usually a better solution.
- */
-
-#ifndef MAX_COM_LENGTH
-#define MAX_COM_LENGTH 65000L	/* must be <= 65533 in any case */
-#endif
-
-
-/*
- * These macros are used to read the input file and write the output file.
- * To reuse this code in another application, you might need to change these.
- */
-
-static FILE * infile;		/* input JPEG file */
-
-/* Return next input byte, or EOF if no more */
-#define NEXTBYTE()  getc(infile)
-
-static FILE * outfile;		/* output JPEG file */
-
-/* Emit an output byte */
-#define PUTBYTE(x)  putc((x), outfile)
-
-
-/* Error exit handler */
-#define ERREXIT(msg)  (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE))
-
-
-/* Read one byte, testing for EOF */
-static int
-read_1_byte (void)
-{
-  int c;
-
-  c = NEXTBYTE();
-  if (c == EOF)
-    ERREXIT("Premature EOF in JPEG file");
-  return c;
-}
-
-/* Read 2 bytes, convert to unsigned int */
-/* All 2-byte quantities in JPEG markers are MSB first */
-static unsigned int
-read_2_bytes (void)
-{
-  int c1, c2;
-
-  c1 = NEXTBYTE();
-  if (c1 == EOF)
-    ERREXIT("Premature EOF in JPEG file");
-  c2 = NEXTBYTE();
-  if (c2 == EOF)
-    ERREXIT("Premature EOF in JPEG file");
-  return (((unsigned int) c1) << 8) + ((unsigned int) c2);
-}
-
-
-/* Routines to write data to output file */
-
-static void
-write_1_byte (int c)
-{
-  PUTBYTE(c);
-}
-
-static void
-write_2_bytes (unsigned int val)
-{
-  PUTBYTE((val >> 8) & 0xFF);
-  PUTBYTE(val & 0xFF);
-}
-
-static void
-write_marker (int marker)
-{
-  PUTBYTE(0xFF);
-  PUTBYTE(marker);
-}
-
-static void
-copy_rest_of_file (void)
-{
-  int c;
-
-  while ((c = NEXTBYTE()) != EOF)
-    PUTBYTE(c);
-}
-
-
-/*
- * JPEG markers consist of one or more 0xFF bytes, followed by a marker
- * code byte (which is not an FF).  Here are the marker codes of interest
- * in this program.  (See jdmarker.c for a more complete list.)
- */
-
-#define M_SOF0  0xC0		/* Start Of Frame N */
-#define M_SOF1  0xC1		/* N indicates which compression process */
-#define M_SOF2  0xC2		/* Only SOF0-SOF2 are now in common use */
-#define M_SOF3  0xC3
-#define M_SOF5  0xC5		/* NB: codes C4 and CC are NOT SOF markers */
-#define M_SOF6  0xC6
-#define M_SOF7  0xC7
-#define M_SOF9  0xC9
-#define M_SOF10 0xCA
-#define M_SOF11 0xCB
-#define M_SOF13 0xCD
-#define M_SOF14 0xCE
-#define M_SOF15 0xCF
-#define M_SOI   0xD8		/* Start Of Image (beginning of datastream) */
-#define M_EOI   0xD9		/* End Of Image (end of datastream) */
-#define M_SOS   0xDA		/* Start Of Scan (begins compressed data) */
-#define M_COM   0xFE		/* COMment */
-
-
-/*
- * Find the next JPEG marker and return its marker code.
- * We expect at least one FF byte, possibly more if the compressor used FFs
- * to pad the file.  (Padding FFs will NOT be replicated in the output file.)
- * There could also be non-FF garbage between markers.  The treatment of such
- * garbage is unspecified; we choose to skip over it but emit a warning msg.
- * NB: this routine must not be used after seeing SOS marker, since it will
- * not deal correctly with FF/00 sequences in the compressed image data...
- */
-
-static int
-next_marker (void)
-{
-  int c;
-  int discarded_bytes = 0;
-
-  /* Find 0xFF byte; count and skip any non-FFs. */
-  c = read_1_byte();
-  while (c != 0xFF) {
-    discarded_bytes++;
-    c = read_1_byte();
-  }
-  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs
-   * are legal as pad bytes, so don't count them in discarded_bytes.
-   */
-  do {
-    c = read_1_byte();
-  } while (c == 0xFF);
-
-  if (discarded_bytes != 0) {
-    fprintf(stderr, "Warning: garbage data found in JPEG file\n");
-  }
-
-  return c;
-}
-
-
-/*
- * Read the initial marker, which should be SOI.
- * For a JFIF file, the first two bytes of the file should be literally
- * 0xFF M_SOI.  To be more general, we could use next_marker, but if the
- * input file weren't actually JPEG at all, next_marker might read the whole
- * file and then return a misleading error message...
- */
-
-static int
-first_marker (void)
-{
-  int c1, c2;
-
-  c1 = NEXTBYTE();
-  c2 = NEXTBYTE();
-  if (c1 != 0xFF || c2 != M_SOI)
-    ERREXIT("Not a JPEG file");
-  return c2;
-}
-
-
-/*
- * Most types of marker are followed by a variable-length parameter segment.
- * This routine skips over the parameters for any marker we don't otherwise
- * want to process.
- * Note that we MUST skip the parameter segment explicitly in order not to
- * be fooled by 0xFF bytes that might appear within the parameter segment;
- * such bytes do NOT introduce new markers.
- */
-
-static void
-copy_variable (void)
-/* Copy an unknown or uninteresting variable-length marker */
-{
-  unsigned int length;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  write_2_bytes(length);
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2)
-    ERREXIT("Erroneous JPEG marker length");
-  length -= 2;
-  /* Skip over the remaining bytes */
-  while (length > 0) {
-    write_1_byte(read_1_byte());
-    length--;
-  }
-}
-
-static void
-skip_variable (void)
-/* Skip over an unknown or uninteresting variable-length marker */
-{
-  unsigned int length;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2)
-    ERREXIT("Erroneous JPEG marker length");
-  length -= 2;
-  /* Skip over the remaining bytes */
-  while (length > 0) {
-    (void) read_1_byte();
-    length--;
-  }
-}
-
-
-/*
- * Parse the marker stream until SOFn or EOI is seen;
- * copy data to output, but discard COM markers unless keep_COM is true.
- */
-
-static int
-scan_JPEG_header (int keep_COM)
-{
-  int marker;
-
-  /* Expect SOI at start of file */
-  if (first_marker() != M_SOI)
-    ERREXIT("Expected SOI marker first");
-  write_marker(M_SOI);
-
-  /* Scan miscellaneous markers until we reach SOFn. */
-  for (;;) {
-    marker = next_marker();
-    switch (marker) {
-      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,
-       * treated as SOFn.  C4 in particular is actually DHT.
-       */
-    case M_SOF0:		/* Baseline */
-    case M_SOF1:		/* Extended sequential, Huffman */
-    case M_SOF2:		/* Progressive, Huffman */
-    case M_SOF3:		/* Lossless, Huffman */
-    case M_SOF5:		/* Differential sequential, Huffman */
-    case M_SOF6:		/* Differential progressive, Huffman */
-    case M_SOF7:		/* Differential lossless, Huffman */
-    case M_SOF9:		/* Extended sequential, arithmetic */
-    case M_SOF10:		/* Progressive, arithmetic */
-    case M_SOF11:		/* Lossless, arithmetic */
-    case M_SOF13:		/* Differential sequential, arithmetic */
-    case M_SOF14:		/* Differential progressive, arithmetic */
-    case M_SOF15:		/* Differential lossless, arithmetic */
-      return marker;
-
-    case M_SOS:			/* should not see compressed data before SOF */
-      ERREXIT("SOS without prior SOFn");
-      break;
-
-    case M_EOI:			/* in case it's a tables-only JPEG stream */
-      return marker;
-
-    case M_COM:			/* Existing COM: conditionally discard */
-      if (keep_COM) {
-	write_marker(marker);
-	copy_variable();
-      } else {
-	skip_variable();
-      }
-      break;
-
-    default:			/* Anything else just gets copied */
-      write_marker(marker);
-      copy_variable();		/* we assume it has a parameter count... */
-      break;
-    }
-  } /* end loop */
-}
-
-
-/* Command line parsing code */
-
-static const char * progname;	/* program name for error messages */
-
-
-static void
-usage (void)
-/* complain about bad command line */
-{
-  fprintf(stderr, "wrjpgcom inserts a textual comment in a JPEG file.\n");
-  fprintf(stderr, "You can add to or replace any existing comment(s).\n");
-
-  fprintf(stderr, "Usage: %s [switches] ", progname);
-#ifdef TWO_FILE_COMMANDLINE
-  fprintf(stderr, "inputfile outputfile\n");
-#else
-  fprintf(stderr, "[inputfile]\n");
-#endif
-
-  fprintf(stderr, "Switches (names may be abbreviated):\n");
-  fprintf(stderr, "  -replace         Delete any existing comments\n");
-  fprintf(stderr, "  -comment \"text\"  Insert comment with given text\n");
-  fprintf(stderr, "  -cfile name      Read comment from named file\n");
-  fprintf(stderr, "Notice that you must put quotes around the comment text\n");
-  fprintf(stderr, "when you use -comment.\n");
-  fprintf(stderr, "If you do not give either -comment or -cfile on the command line,\n");
-  fprintf(stderr, "then the comment text is read from standard input.\n");
-  fprintf(stderr, "It can be multiple lines, up to %u characters total.\n",
-	  (unsigned int) MAX_COM_LENGTH);
-#ifndef TWO_FILE_COMMANDLINE
-  fprintf(stderr, "You must specify an input JPEG file name when supplying\n");
-  fprintf(stderr, "comment text from standard input.\n");
-#endif
-
-  exit(EXIT_FAILURE);
-}
-
-
-static int
-keymatch (char * arg, const char * keyword, int minchars)
-/* Case-insensitive matching of (possibly abbreviated) keyword switches. */
-/* keyword is the constant keyword (must be lower case already), */
-/* minchars is length of minimum legal abbreviation. */
-{
-  register int ca, ck;
-  register int nmatched = 0;
-
-  while ((ca = *arg++) != '\0') {
-    if ((ck = *keyword++) == '\0')
-      return 0;			/* arg longer than keyword, no good */
-    if (isupper(ca))		/* force arg to lcase (assume ck is already) */
-      ca = tolower(ca);
-    if (ca != ck)
-      return 0;			/* no good */
-    nmatched++;			/* count matched characters */
-  }
-  /* reached end of argument; fail if it's too short for unique abbrev */
-  if (nmatched < minchars)
-    return 0;
-  return 1;			/* A-OK */
-}
-
-
-/*
- * The main program.
- */
-
-int
-main (int argc, char **argv)
-{
-  int argn;
-  char * arg;
-  int keep_COM = 1;
-  char * comment_arg = NULL;
-  FILE * comment_file = NULL;
-  unsigned int comment_length = 0;
-  int marker;
-
-  /* On Mac, fetch a command line. */
-#ifdef USE_CCOMMAND
-  argc = ccommand(&argv);
-#endif
-
-  progname = argv[0];
-  if (progname == NULL || progname[0] == 0)
-    progname = "wrjpgcom";	/* in case C library doesn't provide it */
-
-  /* Parse switches, if any */
-  for (argn = 1; argn < argc; argn++) {
-    arg = argv[argn];
-    if (arg[0] != '-')
-      break;			/* not switch, must be file name */
-    arg++;			/* advance over '-' */
-    if (keymatch(arg, "replace", 1)) {
-      keep_COM = 0;
-    } else if (keymatch(arg, "cfile", 2)) {
-      if (++argn >= argc) usage();
-      if ((comment_file = fopen(argv[argn], "r")) == NULL) {
-	fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
-	exit(EXIT_FAILURE);
-      }
-    } else if (keymatch(arg, "comment", 1)) {
-      if (++argn >= argc) usage();
-      comment_arg = argv[argn];
-      /* If the comment text starts with '"', then we are probably running
-       * under MS-DOG and must parse out the quoted string ourselves.  Sigh.
-       */
-      if (comment_arg[0] == '"') {
-	comment_arg = (char *) malloc((size_t) MAX_COM_LENGTH);
-	if (comment_arg == NULL)
-	  ERREXIT("Insufficient memory");
-	strcpy(comment_arg, argv[argn]+1);
-	for (;;) {
-	  comment_length = (unsigned int) strlen(comment_arg);
-	  if (comment_length > 0 && comment_arg[comment_length-1] == '"') {
-	    comment_arg[comment_length-1] = '\0'; /* zap terminating quote */
-	    break;
-	  }
-	  if (++argn >= argc)
-	    ERREXIT("Missing ending quote mark");
-	  strcat(comment_arg, " ");
-	  strcat(comment_arg, argv[argn]);
-	}
-      }
-      comment_length = (unsigned int) strlen(comment_arg);
-    } else
-      usage();
-  }
-
-  /* Cannot use both -comment and -cfile. */
-  if (comment_arg != NULL && comment_file != NULL)
-    usage();
-  /* If there is neither -comment nor -cfile, we will read the comment text
-   * from stdin; in this case there MUST be an input JPEG file name.
-   */
-  if (comment_arg == NULL && comment_file == NULL && argn >= argc)
-    usage();
-
-  /* Open the input file. */
-  if (argn < argc) {
-    if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
-      exit(EXIT_FAILURE);
-    }
-  } else {
-    /* default input file is stdin */
-#ifdef USE_SETMODE		/* need to hack file mode? */
-    setmode(fileno(stdin), O_BINARY);
-#endif
-#ifdef USE_FDOPEN		/* need to re-open in binary mode? */
-    if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
-      fprintf(stderr, "%s: can't open stdin\n", progname);
-      exit(EXIT_FAILURE);
-    }
-#else
-    infile = stdin;
-#endif
-  }
-
-  /* Open the output file. */
-#ifdef TWO_FILE_COMMANDLINE
-  /* Must have explicit output file name */
-  if (argn != argc-2) {
-    fprintf(stderr, "%s: must name one input and one output file\n",
-	    progname);
-    usage();
-  }
-  if ((outfile = fopen(argv[argn+1], WRITE_BINARY)) == NULL) {
-    fprintf(stderr, "%s: can't open %s\n", progname, argv[argn+1]);
-    exit(EXIT_FAILURE);
-  }
-#else
-  /* Unix style: expect zero or one file name */
-  if (argn < argc-1) {
-    fprintf(stderr, "%s: only one input file\n", progname);
-    usage();
-  }
-  /* default output file is stdout */
-#ifdef USE_SETMODE		/* need to hack file mode? */
-  setmode(fileno(stdout), O_BINARY);
-#endif
-#ifdef USE_FDOPEN		/* need to re-open in binary mode? */
-  if ((outfile = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {
-    fprintf(stderr, "%s: can't open stdout\n", progname);
-    exit(EXIT_FAILURE);
-  }
-#else
-  outfile = stdout;
-#endif
-#endif /* TWO_FILE_COMMANDLINE */
-
-  /* Collect comment text from comment_file or stdin, if necessary */
-  if (comment_arg == NULL) {
-    FILE * src_file;
-    int c;
-
-    comment_arg = (char *) malloc((size_t) MAX_COM_LENGTH);
-    if (comment_arg == NULL)
-      ERREXIT("Insufficient memory");
-    comment_length = 0;
-    src_file = (comment_file != NULL ? comment_file : stdin);
-    while ((c = getc(src_file)) != EOF) {
-      if (comment_length >= (unsigned int) MAX_COM_LENGTH) {
-	fprintf(stderr, "Comment text may not exceed %u bytes\n",
-		(unsigned int) MAX_COM_LENGTH);
-	exit(EXIT_FAILURE);
-      }
-      comment_arg[comment_length++] = (char) c;
-    }
-    if (comment_file != NULL)
-      fclose(comment_file);
-  }
-
-  /* Copy JPEG headers until SOFn marker;
-   * we will insert the new comment marker just before SOFn.
-   * This (a) causes the new comment to appear after, rather than before,
-   * existing comments; and (b) ensures that comments come after any JFIF
-   * or JFXX markers, as required by the JFIF specification.
-   */
-  marker = scan_JPEG_header(keep_COM);
-  /* Insert the new COM marker, but only if nonempty text has been supplied */
-  if (comment_length > 0) {
-    write_marker(M_COM);
-    write_2_bytes(comment_length + 2);
-    while (comment_length > 0) {
-      write_1_byte(*comment_arg++);
-      comment_length--;
-    }
-  }
-  /* Duplicate the remainder of the source file.
-   * Note that any COM markers occuring after SOF will not be touched.
-   */
-  write_marker(marker);
-  copy_rest_of_file();
-
-  /* All done. */
-  exit(EXIT_SUCCESS);
-  return 0;			/* suppress no-return-value warnings */
-}
+/*

+ * wrjpgcom.c

+ *

+ * Copyright (C) 1994-1997, Thomas G. Lane.

+ * This file is part of the Independent JPEG Group's software.

+ * For conditions of distribution and use, see the accompanying README file.

+ *

+ * This file contains a very simple stand-alone application that inserts

+ * user-supplied text as a COM (comment) marker in a JFIF file.

+ * This may be useful as an example of the minimum logic needed to parse

+ * JPEG markers.

+ */

+

+#define JPEG_CJPEG_DJPEG	/* to get the command-line config symbols */

+#include "jinclude.h"		/* get auto-config symbols, <stdio.h> */

+

+#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare malloc() */

+extern void * malloc ();

+#endif

+#include <ctype.h>		/* to declare isupper(), tolower() */

+#ifdef USE_SETMODE

+#include <fcntl.h>		/* to declare setmode()'s parameter macros */

+/* If you have setmode() but not <io.h>, just delete this line: */

+#include <io.h>			/* to declare setmode() */

+#endif

+

+#ifdef USE_CCOMMAND		/* command-line reader for Macintosh */

+#ifdef __MWERKS__

+#include <SIOUX.h>              /* Metrowerks needs this */

+#include <console.h>		/* ... and this */

+#endif

+#ifdef THINK_C

+#include <console.h>		/* Think declares it here */

+#endif

+#endif

+

+#ifdef DONT_USE_B_MODE		/* define mode parameters for fopen() */

+#define READ_BINARY	"r"

+#define WRITE_BINARY	"w"

+#else

+#ifdef VMS			/* VMS is very nonstandard */

+#define READ_BINARY	"rb", "ctx=stm"

+#define WRITE_BINARY	"wb", "ctx=stm"

+#else				/* standard ANSI-compliant case */

+#define READ_BINARY	"rb"

+#define WRITE_BINARY	"wb"

+#endif

+#endif

+

+#ifndef EXIT_FAILURE		/* define exit() codes if not provided */

+#define EXIT_FAILURE  1

+#endif

+#ifndef EXIT_SUCCESS

+#ifdef VMS

+#define EXIT_SUCCESS  1		/* VMS is very nonstandard */

+#else

+#define EXIT_SUCCESS  0

+#endif

+#endif

+

+/* Reduce this value if your malloc() can't allocate blocks up to 64K.

+ * On DOS, compiling in large model is usually a better solution.

+ */

+

+#ifndef MAX_COM_LENGTH

+#define MAX_COM_LENGTH 65000L	/* must be <= 65533 in any case */

+#endif

+

+

+/*

+ * These macros are used to read the input file and write the output file.

+ * To reuse this code in another application, you might need to change these.

+ */

+

+static FILE * infile;		/* input JPEG file */

+

+/* Return next input byte, or EOF if no more */

+#define NEXTBYTE()  getc(infile)

+

+static FILE * outfile;		/* output JPEG file */

+

+/* Emit an output byte */

+#define PUTBYTE(x)  putc((x), outfile)

+

+

+/* Error exit handler */

+#define ERREXIT(msg)  (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE))

+

+

+/* Read one byte, testing for EOF */

+static int

+read_1_byte (void)

+{

+  int c;

+

+  c = NEXTBYTE();

+  if (c == EOF)

+    ERREXIT("Premature EOF in JPEG file");

+  return c;

+}

+

+/* Read 2 bytes, convert to unsigned int */

+/* All 2-byte quantities in JPEG markers are MSB first */

+static unsigned int

+read_2_bytes (void)

+{

+  int c1, c2;

+

+  c1 = NEXTBYTE();

+  if (c1 == EOF)

+    ERREXIT("Premature EOF in JPEG file");

+  c2 = NEXTBYTE();

+  if (c2 == EOF)

+    ERREXIT("Premature EOF in JPEG file");

+  return (((unsigned int) c1) << 8) + ((unsigned int) c2);

+}

+

+

+/* Routines to write data to output file */

+

+static void

+write_1_byte (int c)

+{

+  PUTBYTE(c);

+}

+

+static void

+write_2_bytes (unsigned int val)

+{

+  PUTBYTE((val >> 8) & 0xFF);

+  PUTBYTE(val & 0xFF);

+}

+

+static void

+write_marker (int marker)

+{

+  PUTBYTE(0xFF);

+  PUTBYTE(marker);

+}

+

+static void

+copy_rest_of_file (void)

+{

+  int c;

+

+  while ((c = NEXTBYTE()) != EOF)

+    PUTBYTE(c);

+}

+

+

+/*

+ * JPEG markers consist of one or more 0xFF bytes, followed by a marker

+ * code byte (which is not an FF).  Here are the marker codes of interest

+ * in this program.  (See jdmarker.c for a more complete list.)

+ */

+

+#define M_SOF0  0xC0		/* Start Of Frame N */

+#define M_SOF1  0xC1		/* N indicates which compression process */

+#define M_SOF2  0xC2		/* Only SOF0-SOF2 are now in common use */

+#define M_SOF3  0xC3

+#define M_SOF5  0xC5		/* NB: codes C4 and CC are NOT SOF markers */

+#define M_SOF6  0xC6

+#define M_SOF7  0xC7

+#define M_SOF9  0xC9

+#define M_SOF10 0xCA

+#define M_SOF11 0xCB

+#define M_SOF13 0xCD

+#define M_SOF14 0xCE

+#define M_SOF15 0xCF

+#define M_SOI   0xD8		/* Start Of Image (beginning of datastream) */

+#define M_EOI   0xD9		/* End Of Image (end of datastream) */

+#define M_SOS   0xDA		/* Start Of Scan (begins compressed data) */

+#define M_COM   0xFE		/* COMment */

+

+

+/*

+ * Find the next JPEG marker and return its marker code.

+ * We expect at least one FF byte, possibly more if the compressor used FFs

+ * to pad the file.  (Padding FFs will NOT be replicated in the output file.)

+ * There could also be non-FF garbage between markers.  The treatment of such

+ * garbage is unspecified; we choose to skip over it but emit a warning msg.

+ * NB: this routine must not be used after seeing SOS marker, since it will

+ * not deal correctly with FF/00 sequences in the compressed image data...

+ */

+

+static int

+next_marker (void)

+{

+  int c;

+  int discarded_bytes = 0;

+

+  /* Find 0xFF byte; count and skip any non-FFs. */

+  c = read_1_byte();

+  while (c != 0xFF) {

+    discarded_bytes++;

+    c = read_1_byte();

+  }

+  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs

+   * are legal as pad bytes, so don't count them in discarded_bytes.

+   */

+  do {

+    c = read_1_byte();

+  } while (c == 0xFF);

+

+  if (discarded_bytes != 0) {

+    fprintf(stderr, "Warning: garbage data found in JPEG file\n");

+  }

+

+  return c;

+}

+

+

+/*

+ * Read the initial marker, which should be SOI.

+ * For a JFIF file, the first two bytes of the file should be literally

+ * 0xFF M_SOI.  To be more general, we could use next_marker, but if the

+ * input file weren't actually JPEG at all, next_marker might read the whole

+ * file and then return a misleading error message...

+ */

+

+static int

+first_marker (void)

+{

+  int c1, c2;

+

+  c1 = NEXTBYTE();

+  c2 = NEXTBYTE();

+  if (c1 != 0xFF || c2 != M_SOI)

+    ERREXIT("Not a JPEG file");

+  return c2;

+}

+

+

+/*

+ * Most types of marker are followed by a variable-length parameter segment.

+ * This routine skips over the parameters for any marker we don't otherwise

+ * want to process.

+ * Note that we MUST skip the parameter segment explicitly in order not to

+ * be fooled by 0xFF bytes that might appear within the parameter segment;

+ * such bytes do NOT introduce new markers.

+ */

+

+static void

+copy_variable (void)

+/* Copy an unknown or uninteresting variable-length marker */

+{

+  unsigned int length;

+

+  /* Get the marker parameter length count */

+  length = read_2_bytes();

+  write_2_bytes(length);

+  /* Length includes itself, so must be at least 2 */

+  if (length < 2)

+    ERREXIT("Erroneous JPEG marker length");

+  length -= 2;

+  /* Skip over the remaining bytes */

+  while (length > 0) {

+    write_1_byte(read_1_byte());

+    length--;

+  }

+}

+

+static void

+skip_variable (void)

+/* Skip over an unknown or uninteresting variable-length marker */

+{

+  unsigned int length;

+

+  /* Get the marker parameter length count */

+  length = read_2_bytes();

+  /* Length includes itself, so must be at least 2 */

+  if (length < 2)

+    ERREXIT("Erroneous JPEG marker length");

+  length -= 2;

+  /* Skip over the remaining bytes */

+  while (length > 0) {

+    (void) read_1_byte();

+    length--;

+  }

+}

+

+

+/*

+ * Parse the marker stream until SOFn or EOI is seen;

+ * copy data to output, but discard COM markers unless keep_COM is true.

+ */

+

+static int

+scan_JPEG_header (int keep_COM)

+{

+  int marker;

+

+  /* Expect SOI at start of file */

+  if (first_marker() != M_SOI)

+    ERREXIT("Expected SOI marker first");

+  write_marker(M_SOI);

+

+  /* Scan miscellaneous markers until we reach SOFn. */

+  for (;;) {

+    marker = next_marker();

+    switch (marker) {

+      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,

+       * treated as SOFn.  C4 in particular is actually DHT.

+       */

+    case M_SOF0:		/* Baseline */

+    case M_SOF1:		/* Extended sequential, Huffman */

+    case M_SOF2:		/* Progressive, Huffman */

+    case M_SOF3:		/* Lossless, Huffman */

+    case M_SOF5:		/* Differential sequential, Huffman */

+    case M_SOF6:		/* Differential progressive, Huffman */

+    case M_SOF7:		/* Differential lossless, Huffman */

+    case M_SOF9:		/* Extended sequential, arithmetic */

+    case M_SOF10:		/* Progressive, arithmetic */

+    case M_SOF11:		/* Lossless, arithmetic */

+    case M_SOF13:		/* Differential sequential, arithmetic */

+    case M_SOF14:		/* Differential progressive, arithmetic */

+    case M_SOF15:		/* Differential lossless, arithmetic */

+      return marker;

+

+    case M_SOS:			/* should not see compressed data before SOF */

+      ERREXIT("SOS without prior SOFn");

+      break;

+

+    case M_EOI:			/* in case it's a tables-only JPEG stream */

+      return marker;

+

+    case M_COM:			/* Existing COM: conditionally discard */

+      if (keep_COM) {

+	write_marker(marker);

+	copy_variable();

+      } else {

+	skip_variable();

+      }

+      break;

+

+    default:			/* Anything else just gets copied */

+      write_marker(marker);

+      copy_variable();		/* we assume it has a parameter count... */

+      break;

+    }

+  } /* end loop */

+}

+

+

+/* Command line parsing code */

+

+static const char * progname;	/* program name for error messages */

+

+

+static void

+usage (void)

+/* complain about bad command line */

+{

+  fprintf(stderr, "wrjpgcom inserts a textual comment in a JPEG file.\n");

+  fprintf(stderr, "You can add to or replace any existing comment(s).\n");

+

+  fprintf(stderr, "Usage: %s [switches] ", progname);

+#ifdef TWO_FILE_COMMANDLINE

+  fprintf(stderr, "inputfile outputfile\n");

+#else

+  fprintf(stderr, "[inputfile]\n");

+#endif

+

+  fprintf(stderr, "Switches (names may be abbreviated):\n");

+  fprintf(stderr, "  -replace         Delete any existing comments\n");

+  fprintf(stderr, "  -comment \"text\"  Insert comment with given text\n");

+  fprintf(stderr, "  -cfile name      Read comment from named file\n");

+  fprintf(stderr, "Notice that you must put quotes around the comment text\n");

+  fprintf(stderr, "when you use -comment.\n");

+  fprintf(stderr, "If you do not give either -comment or -cfile on the command line,\n");

+  fprintf(stderr, "then the comment text is read from standard input.\n");

+  fprintf(stderr, "It can be multiple lines, up to %u characters total.\n",

+	  (unsigned int) MAX_COM_LENGTH);

+#ifndef TWO_FILE_COMMANDLINE

+  fprintf(stderr, "You must specify an input JPEG file name when supplying\n");

+  fprintf(stderr, "comment text from standard input.\n");

+#endif

+

+  exit(EXIT_FAILURE);

+}

+

+

+static int

+keymatch (char * arg, const char * keyword, int minchars)

+/* Case-insensitive matching of (possibly abbreviated) keyword switches. */

+/* keyword is the constant keyword (must be lower case already), */

+/* minchars is length of minimum legal abbreviation. */

+{

+  register int ca, ck;

+  register int nmatched = 0;

+

+  while ((ca = *arg++) != '\0') {

+    if ((ck = *keyword++) == '\0')

+      return 0;			/* arg longer than keyword, no good */

+    if (isupper(ca))		/* force arg to lcase (assume ck is already) */

+      ca = tolower(ca);

+    if (ca != ck)

+      return 0;			/* no good */

+    nmatched++;			/* count matched characters */

+  }

+  /* reached end of argument; fail if it's too short for unique abbrev */

+  if (nmatched < minchars)

+    return 0;

+  return 1;			/* A-OK */

+}

+

+

+/*

+ * The main program.

+ */

+

+int

+main (int argc, char **argv)

+{

+  int argn;

+  char * arg;

+  int keep_COM = 1;

+  char * comment_arg = NULL;

+  FILE * comment_file = NULL;

+  unsigned int comment_length = 0;

+  int marker;

+

+  /* On Mac, fetch a command line. */

+#ifdef USE_CCOMMAND

+  argc = ccommand(&argv);

+#endif

+

+  progname = argv[0];

+  if (progname == NULL || progname[0] == 0)

+    progname = "wrjpgcom";	/* in case C library doesn't provide it */

+

+  /* Parse switches, if any */

+  for (argn = 1; argn < argc; argn++) {

+    arg = argv[argn];

+    if (arg[0] != '-')

+      break;			/* not switch, must be file name */

+    arg++;			/* advance over '-' */

+    if (keymatch(arg, "replace", 1)) {

+      keep_COM = 0;

+    } else if (keymatch(arg, "cfile", 2)) {

+      if (++argn >= argc) usage();

+      if ((comment_file = fopen(argv[argn], "r")) == NULL) {

+	fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);

+	exit(EXIT_FAILURE);

+      }

+    } else if (keymatch(arg, "comment", 1)) {

+      if (++argn >= argc) usage();

+      comment_arg = argv[argn];

+      /* If the comment text starts with '"', then we are probably running

+       * under MS-DOG and must parse out the quoted string ourselves.  Sigh.

+       */

+      if (comment_arg[0] == '"') {

+	comment_arg = (char *) malloc((size_t) MAX_COM_LENGTH);

+	if (comment_arg == NULL)

+	  ERREXIT("Insufficient memory");

+	strcpy(comment_arg, argv[argn]+1);

+	for (;;) {

+	  comment_length = (unsigned int) strlen(comment_arg);

+	  if (comment_length > 0 && comment_arg[comment_length-1] == '"') {

+	    comment_arg[comment_length-1] = '\0'; /* zap terminating quote */

+	    break;

+	  }

+	  if (++argn >= argc)

+	    ERREXIT("Missing ending quote mark");

+	  strcat(comment_arg, " ");

+	  strcat(comment_arg, argv[argn]);

+	}

+      }

+      comment_length = (unsigned int) strlen(comment_arg);

+    } else

+      usage();

+  }

+

+  /* Cannot use both -comment and -cfile. */

+  if (comment_arg != NULL && comment_file != NULL)

+    usage();

+  /* If there is neither -comment nor -cfile, we will read the comment text

+   * from stdin; in this case there MUST be an input JPEG file name.

+   */

+  if (comment_arg == NULL && comment_file == NULL && argn >= argc)

+    usage();

+

+  /* Open the input file. */

+  if (argn < argc) {

+    if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);

+      exit(EXIT_FAILURE);

+    }

+  } else {

+    /* default input file is stdin */

+#ifdef USE_SETMODE		/* need to hack file mode? */

+    setmode(fileno(stdin), O_BINARY);

+#endif

+#ifdef USE_FDOPEN		/* need to re-open in binary mode? */

+    if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) {

+      fprintf(stderr, "%s: can't open stdin\n", progname);

+      exit(EXIT_FAILURE);

+    }

+#else

+    infile = stdin;

+#endif

+  }

+

+  /* Open the output file. */

+#ifdef TWO_FILE_COMMANDLINE

+  /* Must have explicit output file name */

+  if (argn != argc-2) {

+    fprintf(stderr, "%s: must name one input and one output file\n",

+	    progname);

+    usage();

+  }

+  if ((outfile = fopen(argv[argn+1], WRITE_BINARY)) == NULL) {

+    fprintf(stderr, "%s: can't open %s\n", progname, argv[argn+1]);

+    exit(EXIT_FAILURE);

+  }

+#else

+  /* Unix style: expect zero or one file name */

+  if (argn < argc-1) {

+    fprintf(stderr, "%s: only one input file\n", progname);

+    usage();

+  }

+  /* default output file is stdout */

+#ifdef USE_SETMODE		/* need to hack file mode? */

+  setmode(fileno(stdout), O_BINARY);

+#endif

+#ifdef USE_FDOPEN		/* need to re-open in binary mode? */

+  if ((outfile = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {

+    fprintf(stderr, "%s: can't open stdout\n", progname);

+    exit(EXIT_FAILURE);

+  }

+#else

+  outfile = stdout;

+#endif

+#endif /* TWO_FILE_COMMANDLINE */

+

+  /* Collect comment text from comment_file or stdin, if necessary */

+  if (comment_arg == NULL) {

+    FILE * src_file;

+    int c;

+

+    comment_arg = (char *) malloc((size_t) MAX_COM_LENGTH);

+    if (comment_arg == NULL)

+      ERREXIT("Insufficient memory");

+    comment_length = 0;

+    src_file = (comment_file != NULL ? comment_file : stdin);

+    while ((c = getc(src_file)) != EOF) {

+      if (comment_length >= (unsigned int) MAX_COM_LENGTH) {

+	fprintf(stderr, "Comment text may not exceed %u bytes\n",

+		(unsigned int) MAX_COM_LENGTH);

+	exit(EXIT_FAILURE);

+      }

+      comment_arg[comment_length++] = (char) c;

+    }

+    if (comment_file != NULL)

+      fclose(comment_file);

+  }

+

+  /* Copy JPEG headers until SOFn marker;

+   * we will insert the new comment marker just before SOFn.

+   * This (a) causes the new comment to appear after, rather than before,

+   * existing comments; and (b) ensures that comments come after any JFIF

+   * or JFXX markers, as required by the JFIF specification.

+   */

+  marker = scan_JPEG_header(keep_COM);

+  /* Insert the new COM marker, but only if nonempty text has been supplied */

+  if (comment_length > 0) {

+    write_marker(M_COM);

+    write_2_bytes(comment_length + 2);

+    while (comment_length > 0) {

+      write_1_byte(*comment_arg++);

+      comment_length--;

+    }

+  }

+  /* Duplicate the remainder of the source file.

+   * Note that any COM markers occuring after SOF will not be touched.

+   */

+  write_marker(marker);

+  copy_rest_of_file();

+

+  /* All done. */

+  exit(EXIT_SUCCESS);

+  return 0;			/* suppress no-return-value warnings */

+}