From 864c47033c99830262eb7f99fd4fbf19c1c188e1 Mon Sep 17 00:00:00 2001
From: Ben Avison <bavison@gitlab.riscosopen.org>
Date: Thu, 18 Oct 2007 16:20:16 +0000
Subject: [PATCH] Added required documentation for release of source code from
 IJG.

---
 Doc/JPEG/README_first | 2352 +++++++++++++++++++++++++++++++++++++++++
 Doc/JPEG/README_v3    |  360 +++++++
 Doc/JPEG/README_v4    |  401 +++++++
 Doc/JPEG/README_v5    |  349 ++++++
 4 files changed, 3462 insertions(+)
 create mode 100644 Doc/JPEG/README_first
 create mode 100644 Doc/JPEG/README_v3
 create mode 100644 Doc/JPEG/README_v4
 create mode 100644 Doc/JPEG/README_v5

diff --git a/Doc/JPEG/README_first b/Doc/JPEG/README_first
new file mode 100644
index 0000000..d9525e3
--- /dev/null
+++ b/Doc/JPEG/README_first
@@ -0,0 +1,2352 @@
+Some of the accompanying sources were based upon software from the
+Independent JPEG Group, specifically from releases 3, 4 and 5. In accordance
+with the terms of redistribution of that source code, see below the diffs
+from the appropriate release to the earliest revision of each relevant
+source code file in CVS, and see also the matching README file that you
+should have received alongside this one. CVS may be used to derive the diffs
+to other revisions.
+
+BJGA, 2007-10-18
+
+
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-3/jconfig.h cvs/h/jconfig
+--- jpeg-3/jconfig.h	1992-03-08 03:26:04.000000000 +0000
++++ cvs/h/jconfig	1996-11-05 09:45:08.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jconfig.h
+  *
+@@ -5,27 +22,7 @@
+  * 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 preprocessor declarations that help customize
+- * the JPEG software for a particular application, machine, or compiler.
+- * Edit these declarations as needed (or add -D flags to the Makefile).
+- */
+-
+-
+-/*
+- * These symbols indicate the properties of your machine or compiler.
+- * The conditional definitions given may do the right thing already,
+- * but you'd best look them over closely, especially if your compiler
+- * does not handle full ANSI C.  An ANSI-compliant C compiler should
+- * provide all the necessary features; __STDC__ is supposed to be
+- * predefined by such compilers.
+- */
+-
+-/*
+- * HAVE_STDC is tested below to see whether ANSI features are available.
+- * We avoid testing __STDC__ directly for arcane reasons of portability.
+- * (On some compilers, __STDC__ is only defined if a switch is given,
+- * but the switch also disables machine-specific features we need to get at.
+- * In that case, -DHAVE_STDC in the Makefile is a convenient solution.)
++ * Seriously updated for use deep within RISC OS.
+  */
+ 
+ #ifdef __STDC__			/* if compiler claims to be ANSI, believe it */
+@@ -52,153 +48,18 @@
+ #define HAVE_UNSIGNED_SHORT
+ #endif
+ 
+-/* Define this if an ordinary "char" type is unsigned.
+- * If you're not sure, leaving it undefined will work at some cost in speed.
+- * If you defined HAVE_UNSIGNED_CHAR then it doesn't matter very much.
+- */
+-
+-/* #define CHAR_IS_UNSIGNED */
+-
+-/* Define this if your compiler implements ">>" on signed values as a logical
+- * (unsigned) shift; leave it undefined if ">>" is a signed (arithmetic) shift,
+- * which is the normal and rational definition.
+- */
+-
+-/* #define RIGHT_SHIFT_IS_UNSIGNED */
+-
+-/* Define "void" as "char" if your compiler doesn't know about type void.
+- * NOTE: be sure to define void such that "void *" represents the most general
+- * pointer type, e.g., that returned by malloc().
+- */
+-
+-/* #define void char */
+-
+-/* Define const as empty if your compiler doesn't know the "const" keyword. */
+-/* (Even if it does, defining const as empty won't break anything.) */
+-
+-#ifndef HAVE_STDC		/* ANSI C and C++ compilers should know it. */
+-#ifndef __cplusplus
+-#define const
+-#endif
+-#endif
+-
+-/* For 80x86 machines, you need to define NEED_FAR_POINTERS,
+- * unless you are using a large-data memory model or 80386 flat-memory mode.
+- * On less brain-damaged CPUs this symbol must not be defined.
+- * (Defining this symbol causes large data structures to be referenced through
+- * "far" pointers and to be allocated with a special version of malloc.)
+- */
+-
+-#ifdef MSDOS
+-#define NEED_FAR_POINTERS
+-#endif
+-
+-
+-/* The next three symbols only affect the system-dependent user interface
+- * modules (jcmain.c, jdmain.c).  You can ignore these if you are supplying
+- * your own user interface code.
+- */
+-
+-/* Define this if you want to name both input and output files on the command
+- * line, rather than using stdout and optionally stdin.  You MUST do this if
+- * your system can't cope with binary I/O to stdin/stdout.  See comments at
+- * head of jcmain.c or jdmain.c.
+- */
+-
+-#ifdef MSDOS			/* two-file style is needed for PCs */
+-#define TWO_FILE_COMMANDLINE
+-#endif
+-#ifdef THINK_C			/* needed for Macintosh too */
+-#define TWO_FILE_COMMANDLINE
+-#endif
+-
+-/* Define this if your system needs explicit cleanup of temporary files.
+- * This is crucial under MS-DOS, where the temporary "files" may be areas
+- * of extended memory; on most other systems it's not as important.
+- */
+-
+-#ifdef MSDOS
+-#define NEED_SIGNAL_CATCHER
+-#endif
+-
+-/* By default, we open image files with fopen(...,"rb") or fopen(...,"wb").
+- * This is necessary on systems that distinguish text files from binary files,
+- * and is harmless on most systems that don't.  If you have one of the rare
+- * systems that complains about the "b" spec, define this symbol.
+- */
+-
+-/* #define DONT_USE_B_MODE */
+-
+-
+-/* If you're getting bored, that's the end of the symbols you HAVE to
+- * worry about.  Go fix the makefile and compile.
+- */
+-
+-
+-/* On a few systems, type boolean and/or macros FALSE, TRUE may appear
+- * in standard header files.  Or you may have conflicts with application-
+- * specific header files that you want to include together with these files.
+- * In that case you need only comment out these definitions.
+- */
+-
+ typedef int boolean;
++#ifndef BOOL
++  #define BOOL int
++#endif
+ #undef FALSE			/* in case these macros already exist */
+ #undef TRUE
+ #define FALSE	0		/* values of boolean */
+ #define TRUE	1
+ 
+-/* This defines the size of the I/O buffers for entropy compression
+- * and decompression; you could reduce it if memory is tight.
+- */
+-
+-#define JPEG_BUF_SIZE	4096 /* bytes */
+-
+-
+-
+ /* These symbols determine the JPEG functionality supported. */
+ 
+-/*
+- * These defines indicate whether to include various optional functions.
+- * Undefining some of these symbols will produce a smaller but less capable
+- * program file.  Note that you can leave certain source files out of the
+- * compilation/linking process if you've #undef'd the corresponding symbols.
+- * (You may HAVE to do that if your compiler doesn't like null source files.)
+- */
+-
+-/* Arithmetic coding is unsupported for legal reasons.  Complaints to IBM. */
+-#undef  ARITH_CODING_SUPPORTED	/* Arithmetic coding back end? */
+-#define MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+-#define ENTROPY_OPT_SUPPORTED	/* Optimization of entropy coding parms? */
+-#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing during decoding? */
+-#define QUANT_1PASS_SUPPORTED	/* 1-pass color quantization? */
+-#define QUANT_2PASS_SUPPORTED	/* 2-pass color quantization? */
+-/* these defines indicate which JPEG file formats are allowed */
+ #define JFIF_SUPPORTED		/* JFIF or "raw JPEG" files */
+-#undef  JTIFF_SUPPORTED		/* JPEG-in-TIFF (not yet implemented) */
+-/* these defines indicate which image (non-JPEG) file formats are allowed */
+-#define GIF_SUPPORTED		/* GIF image file format */
+-/* #define RLE_SUPPORTED */	/* RLE image file format (by default, no) */
+-#define PPM_SUPPORTED		/* PPM/PGM image file format */
+-#define TARGA_SUPPORTED		/* Targa image file format */
+-#undef  TIFF_SUPPORTED		/* TIFF image file format (not yet impl.) */
+-
+-/* more capability options later, no doubt */
+-
+-
+-/*
+- * Define exactly one of these three symbols to indicate whether you want
+- * 8-bit, 12-bit, or 16-bit sample (pixel component) values.  8-bit is the
+- * default and is nearly always the right thing to use.  You can use 12-bit if
+- * you need to support image formats with more than 8 bits of resolution in a
+- * color value.  16-bit should only be used for the lossless JPEG mode (not
+- * currently supported).  Note that 12- and 16-bit values take up twice as
+- * much memory as 8-bit!
+- * Note: if you select 12- or 16-bit precision, it is dangerous to turn off
+- * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
+- * precision, so jchuff.c normally uses entropy optimization to compute
+- * usable tables for higher precision.  If you don't want to do optimization,
+- * you'll have to supply different default Huffman tables.
+- */
+ 
+ #define EIGHT_BIT_SAMPLES
+ #undef  TWELVE_BIT_SAMPLES
+@@ -295,8 +154,11 @@ typedef unsigned int JSAMPLE;
+  * more will cost you a BIG hit of memory, less will give wrong answers.
+  */
+ 
++#ifdef RISCOS
++typedef int JCOEF;
++#else
+ typedef short JCOEF;
+-
++#endif
+ 
+ /* The remaining typedefs are used for various table entries and so forth.
+  * They must be at least as wide as specified; but making them too big
+@@ -334,6 +196,11 @@ typedef short INT16;
+ /* INT32 must hold signed 32-bit values; if your machine happens */
+ /* to have 64-bit longs, you might want to change this. */
+ 
+-#ifndef XMD_H			/* X11/xmd.h correctly defines INT32 */
+-typedef long INT32;
++#ifdef RISCOS
++typedef int INT32;
++typedef unsigned int UINT32;
++#else
++  #ifndef XMD_H                 /* X11/xmd.h correctly defines INT32 */
++  typedef long INT32;
++  #endif
+ #endif
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-4/jdcolor.c cvs/c/jdcolor
+--- jpeg-4/jdcolor.c	1992-08-23 20:59:39.000000000 +0100
++++ cvs/c/jdcolor	1996-11-05 09:45:02.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jdcolor.c
+  *
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-3/jdhuff.c cvs/c/jdhuff
+--- jpeg-3/jdhuff.c	1992-03-07 00:58:45.000000000 +0000
++++ cvs/c/jdhuff	1996-11-05 09:45:02.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jdhuff.c
+  *
+@@ -8,21 +25,31 @@
+  * This file contains Huffman entropy decoding routines.
+  * These routines are invoked via the methods entropy_decode
+  * and entropy_decoder_init/term.
++
++ * Not only hacked for use deep within RISC OS, but bits of release 4 transplanted in too.
+  */
++#undef FILE_
++#define FILE_ (10000)
+ 
+ #include "jinclude.h"
+ 
+ 
+ /* Static variables to avoid passing 'round extra parameters */
+ 
++#if 0
+ static decompress_info_ptr dcinfo;
+ 
+ static INT32 get_buffer;	/* current bit-extraction buffer */
+ static int bits_left;		/* # of unused bits in it */
++#endif
++/* These have been moved to the cinfo structure, so that there are no
++static variables. */
+ 
++LOCAL int
++huff_DECODE_buildshortcut (decompress_info_ptr cinfo, HUFF_TBL * htbl); /* forward reference */
+ 
+ LOCAL void
+-fix_huff_tbl (HUFF_TBL * htbl)
++fix_huff_tbl (decompress_info_ptr cinfo, HUFF_TBL * htbl)
+ /* Compute derived values for a Huffman table */
+ {
+   int p, i, l, si;
+@@ -64,74 +91,122 @@ fix_huff_tbl (HUFF_TBL * htbl)
+   for (l = 1; l <= 16; l++) {
+     if (htbl->bits[l]) {
+       htbl->valptr[l] = p;	/* huffval[] index of 1st sym of code len l */
+-      htbl->mincode[l] = huffcode[p]; /* minimum code of length l */
++      htbl->valptr[l] -= huffcode[p]; /* subtract value in old 'mincode' table, for speed later */
++      /* htbl->mincode[l] = huffcode[p]; */ /* minimum code of length l */
+       p += htbl->bits[l];
+       htbl->maxcode[l] = huffcode[p-1];	/* maximum code of length l */
+     } else {
+       htbl->maxcode[l] = -1;
+     }
+   }
+-  htbl->maxcode[17] = 0xFFFFFL;	/* ensures huff_DECODE terminates */
+-}
++  htbl->maxcode[17] = 0xFFFFF /*0xFFFFFL*/; /* ensures huff_DECODE terminates */
+ 
++  /* Now we build the shortcut table. Using the above, reading a huffman code
++  proceeds by reading bits one at a time, and looking up the result in a table
++  to see if it is big enough yet. The shortcut table reads the next 8 bits
++  of input, and uses this to index a table that says what to do. This table
++  is constructed by trying all 256 possibles. */
++  {
++    int i; /* index into shortcut table */
++    int h; /* the code you read */
++
++    for (i = 0; i < 256; i++) /* for each element of shortcut table */
++    {
++      cinfo->bits_left = 32;
++      cinfo->get_buffer = i << 24; /* fake the input bits */
++      h = huff_DECODE_buildshortcut(cinfo, htbl); /* the C-coded decoding doesn't use the shortcut table - we haven't built it yet! */
++      if (cinfo->bits_left < 24) /* code longer than 8 bits */
++        htbl->shortcut[i] = -1;
++      else
++      {
++        assert(h >= 0, ERROR_FATAL);
++        htbl->shortcut[i] = ((32 - cinfo->bits_left) << 24) | h; /* remember size and value */
++      }
++    }
++    cinfo->bits_left = 0;
++    cinfo->get_buffer = 0;
++  }
++}
+ 
+ /* Extract the next N bits from the input stream (N <= 15) */
+ 
+ LOCAL int
+-get_bits (int nbits)
++get_bits (decompress_info_ptr cinfo, int nbits)
+ {
+   int result;
+   
+-  while (nbits > bits_left) {
+-    int c = JGETC(dcinfo);
++  while (nbits > cinfo->bits_left) {
++    int c = JGETC(cinfo);
+     
+-    get_buffer <<= 8;
+-    get_buffer |= c;
+-    bits_left += 8;
++    cinfo->get_buffer <<= 8;
++    cinfo->get_buffer |= c;
++    cinfo->bits_left += 8;
+     /* If it's 0xFF, check and discard stuffed zero byte */
+     if (c == 0xff) {
+-      c = JGETC(dcinfo);  /* Byte stuffing */
++      c = JGETC(cinfo);  /* Byte stuffing */
+       if (c != 0)
+-	ERREXIT1(dcinfo->emethods,
++        ERREXIT1(cinfo->emethods,
+ 		 "Unexpected marker 0x%02x in compressed data", c);
+     }
+   }
+   
+-  bits_left -= nbits;
+-  result = ((int) (get_buffer >> bits_left)) & ((1 << nbits) - 1);
++  cinfo->bits_left -= nbits;
++  result = ((int) (cinfo->get_buffer >> cinfo->bits_left)) & ((1 << nbits) - 1);
+   return result;
+ }
+ 
+ /* Macro to make things go at some speed! */
+ 
+-#define get_bit()	(bits_left ? \
+-			 ((int) (get_buffer >> (--bits_left))) & 1 : \
+-			 get_bits(1))
+-
++#define get_bit(cinfo)       (cinfo->bits_left ? \
++                             ((int) (cinfo->get_buffer >> (--cinfo->bits_left))) & 1 : \
++                             get_bits(cinfo, 1))
+ 
+ /* Figure F.16: extract next coded symbol from input stream */
+   
++/* Altered version of huff_DECODE for use in constructing the shortcut table */
+ LOCAL int
+-huff_DECODE (HUFF_TBL * htbl)
++huff_DECODE_buildshortcut (decompress_info_ptr cinfo, HUFF_TBL * htbl)
+ {
+   int l, p;
+   INT32 code;
+   
+-  code = get_bit();
++  code = get_bit(cinfo);
++  l = 1;
++  while (code > htbl->maxcode[l] && l <= 8) {
++    code = (code << 1) + get_bit(cinfo);
++    l++;
++  }
++  if (l > 8) return -1;
++  p = (int) (htbl->valptr[l] + (code /* - htbl->mincode[l] */));
++  return (int) htbl->huffval[p];
++}
++
++#ifndef ASMHUFF
++
++LOCAL int
++huff_DECODE (decompress_info_ptr cinfo, HUFF_TBL * htbl)
++{
++  int l, p;
++  INT32 code;
++
++  code = get_bit(cinfo);
+   l = 1;
+   while (code > htbl->maxcode[l]) {
+-    code = (code << 1) + get_bit();
++    code = (code << 1) + get_bit(cinfo);
+     l++;
+   }
+ 
+   /* With garbage input we may reach the sentinel value l = 17. */
+ 
+   if (l > 16) {
+-    ERREXIT(dcinfo->emethods, "Corrupted data in JPEG file");
++    ERREXIT(cinfo->emethods, "Corrupted data in JPEG file");
+   }
+ 
+-  p = (int) (htbl->valptr[l] + (code - htbl->mincode[l]));
+-  
++  p = (int) (htbl->valptr[l] + (code /* - htbl->mincode[l] */));
++/*
++  tracef("Decoded huffman value=%i next_byte=0x%x bits_left=%i get_buf=0x%x.\n"
++  _ htbl->huffval[p] _ (int)cinfo->next_input_byte _ cinfo->bits_left _ cinfo->get_buffer);
++*/
+   return (int) htbl->huffval[p];
+ }
+ 
+@@ -146,10 +220,59 @@ huff_DECODE (HUFF_TBL * htbl)
+ 
+ 
+ /* Decode a single block's worth of coefficients */
+-/* Note that only the difference is returned for the DC coefficient */
++
++/* ZAG[i] is the natural-order position of the i'th element of zigzag order.
++ * If the incoming data is corrupted, huff_decode_mcu could attempt to
++ * reference values beyond the end of the array.  To avoid a wild store,
++ * we put some extra zeroes after the real entries.
++ */
++
++#if 0
++
++static const short ZAG[DCTSIZE2+16] = {
++  0,  1,  8, 16,  9,  2,  3, 10,
++ 17, 24, 32, 25, 18, 11,  4,  5,
++ 12, 19, 26, 33, 40, 48, 41, 34,
++ 27, 20, 13,  6,  7, 14, 21, 28,
++ 35, 42, 49, 56, 57, 50, 43, 36,
++ 29, 22, 15, 23, 30, 37, 44, 51,
++ 58, 59, 52, 45, 38, 31, 39, 46,
++ 53, 60, 61, 54, 47, 55, 62, 63,
++  0,  0,  0,  0,  0,  0,  0,  0, /* extra entries in case k>63 below */
++  0,  0,  0,  0,  0,  0,  0,  0
++};
++
++/* 2-digit ones in decimal: */
++#define ZAG (\
++"\x00\x01\x08\x16\x09\x02\x03\x10" \
++"\x17\x24\x32\x25\x18\x11\x04\x05" \
++"\x12\x19\x26\x33\x40\x48\x41\x34" \
++"\x27\x20\x13\x06\x07\x14\x21\x28" \
++"\x35\x42\x49\x56\x57\x50\x43\x36" \
++"\x29\x22\x15\x23\x30\x37\x44\x51" \
++"\x58\x59\x52\x45\x38\x31\x39\x46" \
++"\x53\x60\x61\x54\x47\x55\x62\x63" \
++"\x00\x00\x00\x00\x00\x00\x00\x00" \
++"\x00\x00\x00\x00\x00\x00\x00\x00")
++
++#else
++
++#define ZAG (\
++"\x00\x01\x08\x10\x09\x02\x03\x0a" \
++"\x11\x18\x20\x19\x12\x0b\x04\x05" \
++"\x0c\x13\x1a\x21\x28\x30\x29\x22" \
++"\x1b\x14\x0d\x06\x07\x0e\x15\x1c" \
++"\x23\x2a\x31\x38\x39\x32\x2b\x24" \
++"\x1d\x16\x0f\x17\x1e\x25\x2c\x33" \
++"\x3a\x3b\x34\x2d\x26\x1f\x27\x2e" \
++"\x35\x3c\x3d\x36\x2f\x37\x3e\x3f" \
++"\x00\x00\x00\x00\x00\x00\x00\x00" \
++"\x00\x00\x00\x00\x00\x00\x00\x00")
++
++#endif
+ 
+ LOCAL void
+-decode_one_block (JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl)
++decode_one_block (decompress_info_ptr cinfo, JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl, QUANT_TBL_PTR quanttbl, int *last_dc_val)
+ {
+   int s, k, r, n;
+ 
+@@ -159,25 +282,31 @@ decode_one_block (JBLOCK block, HUFF_TBL
+   
+   /* Section F.2.2.1: decode the DC coefficient difference */
+ 
+-  s = huff_DECODE(dctbl);
++  s = huff_DECODE(cinfo, dctbl);
+   if (s) {
+-    r = get_bits(s);
++    r = get_bits(cinfo, s);
+     s = huff_EXTEND(r, s);
+   }
+-  block[0] = s;
++  /* Convert DC difference to actual value, update last_dc_val */
++  s += *last_dc_val;
++  *last_dc_val = (JCOEF) s;
++  /* Descale and output the DC coefficient (assumes ZAG[0] = 0) */
++  block[0] = (JCOEF) (((JCOEF) s) * quanttbl[0]);
+ 
+   /* Section F.2.2.2: decode the AC coefficients */
+   
+   for (k = 1; k < DCTSIZE2; k++) {
+-    r = huff_DECODE(actbl);
++    r = huff_DECODE(cinfo, actbl);
+     
+     s = r & 15;
+     n = r >> 4;
+     
+     if (s) {
+       k += n;
+-      r = get_bits(s);
+-      block[k] = huff_EXTEND(r, s);
++      r = get_bits(cinfo, s);
++      s = huff_EXTEND(r, s);
++      /* Descale coefficient and output in natural (dezigzagged) order */
++      block[ZAG[k]] = (JCOEF) (((JCOEF) s) * quanttbl[k]);
+     } else {
+       if (n != 15)
+ 	break;
+@@ -186,140 +315,81 @@ decode_one_block (JBLOCK block, HUFF_TBL
+   }
+ }
+ 
+-
+-/*
+- * Initialize for a Huffman-compressed scan.
+- * This is invoked after reading the SOS marker.
+- */
+-
+-METHODDEF void
+-huff_decoder_init (decompress_info_ptr cinfo)
+-{
+-  short ci;
+-  jpeg_component_info * compptr;
+-
+-  /* Initialize static variables */
+-  dcinfo = cinfo;
+-  bits_left = 0;
+-
+-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+-    compptr = cinfo->cur_comp_info[ci];
+-    /* Make sure requested tables are present */
+-    if (cinfo->dc_huff_tbl_ptrs[compptr->dc_tbl_no] == NULL ||
+-	cinfo->ac_huff_tbl_ptrs[compptr->ac_tbl_no] == NULL)
+-      ERREXIT(cinfo->emethods, "Use of undefined Huffman table");
+-    /* Compute derived values for Huffman tables */
+-    /* We may do this more than once for same table, but it's not a big deal */
+-    fix_huff_tbl(cinfo->dc_huff_tbl_ptrs[compptr->dc_tbl_no]);
+-    fix_huff_tbl(cinfo->ac_huff_tbl_ptrs[compptr->ac_tbl_no]);
+-    /* Initialize DC predictions to 0 */
+-    cinfo->last_dc_val[ci] = 0;
+-  }
+-
+-  /* Initialize restart stuff */
+-  cinfo->restarts_to_go = cinfo->restart_interval;
+-  cinfo->next_restart_num = 0;
+-}
+-
+-
+-/*
+- * Check for a restart marker & resynchronize decoder.
+- */
+-
+ LOCAL void
+-process_restart (decompress_info_ptr cinfo)
++skip_one_block (decompress_info_ptr cinfo, HUFF_TBL *dctbl, HUFF_TBL *actbl, int *last_dc_val)
++/* Like decode_one_block in its effect on *last_dc_val and the source of the input stream,
++but no block of coefficients need be produced. */
+ {
+-  int c, nbytes;
+-  short ci;
++  int s, k, r, n;
+ 
+-  /* Throw away any partial unread byte */
+-  bits_left = 0;
++  /* Section F.2.2.1: decode the DC coefficient difference */
+ 
+-  /* Scan for next JPEG marker */
+-  nbytes = 0;
+-  do {
+-    do {			/* skip any non-FF bytes */
+-      nbytes++;
+-      c = JGETC(cinfo);
+-    } while (c != 0xFF);
+-    do {			/* skip any duplicate FFs */
+-      nbytes++;
+-      c = JGETC(cinfo);
+-    } while (c == 0xFF);
+-  } while (c == 0);		/* repeat if it was a stuffed FF/00 */
++  s = huff_DECODE(cinfo, dctbl);
++  if (s) {
++    r = get_bits(cinfo, s);
++    s = huff_EXTEND(r, s);
++  }
++  /* Convert DC difference to actual value, update last_dc_val */
++  s += *last_dc_val;
++  *last_dc_val = (JCOEF) s;
+ 
+-  if (c != (RST0 + cinfo->next_restart_num))
+-    ERREXIT2(cinfo->emethods, "Found 0x%02x marker instead of RST%d",
+-	     c, cinfo->next_restart_num);
++  /* Section F.2.2.2: decode the AC coefficients */
+ 
+-  if (nbytes != 2)
+-    TRACEMS2(cinfo->emethods, 1, "Skipped %d bytes before RST%d",
+-	     nbytes-2, cinfo->next_restart_num);
+-  else
+-    TRACEMS1(cinfo->emethods, 2, "RST%d", cinfo->next_restart_num);
++  for (k = 1; k < DCTSIZE2; k++) {
++    r = huff_DECODE(cinfo, actbl);
+ 
+-  /* Re-initialize DC predictions to 0 */
+-  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+-    cinfo->last_dc_val[ci] = 0;
++    s = r & 15;
++    n = r >> 4;
+ 
+-  /* Update restart state */
+-  cinfo->restarts_to_go = cinfo->restart_interval;
+-  cinfo->next_restart_num++;
+-  cinfo->next_restart_num &= 7;
++    if (s) {
++      k += n;
++      r = get_bits(cinfo, s);
++    } else {
++      if (n != 15)
++        break;
++      k += 15;
++    }
++  }
+ }
+ 
+-
+-/*
+- * Decode and return one MCU's worth of Huffman-compressed coefficients.
+- */
+-
+-METHODDEF void
+-huff_decode (decompress_info_ptr cinfo, JBLOCK *MCU_data)
++LOCAL void
++huff_decode_blocks(decompress_info_ptr cinfo, JBLOCK block,
++                   HUFF_TBL *dctbl, HUFF_TBL *actbl, QUANT_TBL_PTR quanttbl,
++                   int *last_dc_val, int nblocks)
+ {
+-  short blkn, ci;
+-  jpeg_component_info * compptr;
+-
+-  /* Account for restart interval, process restart marker if needed */
+-  if (cinfo->restart_interval) {
+-    if (cinfo->restarts_to_go == 0)
+-      process_restart(cinfo);
+-    cinfo->restarts_to_go--;
++  while (nblocks > 0)
++  {
++    decode_one_block(cinfo,block,dctbl,actbl,quanttbl,last_dc_val);
++    nblocks--;
+   }
++}
+ 
+-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+-    ci = cinfo->MCU_membership[blkn];
+-    compptr = cinfo->cur_comp_info[ci];
+-    decode_one_block(MCU_data[blkn],
+-		     cinfo->dc_huff_tbl_ptrs[compptr->dc_tbl_no],
+-		     cinfo->ac_huff_tbl_ptrs[compptr->ac_tbl_no]);
+-    /* Convert DC difference to actual value, update last_dc_val */
+-    MCU_data[blkn][0] += cinfo->last_dc_val[ci];
+-    cinfo->last_dc_val[ci] = MCU_data[blkn][0];
++extern void
++huff_skip_blocks (decompress_info_ptr cinfo, JBLOCK block,
++                  HUFF_TBL *dctbl, HUFF_TBL *actbl,
++                  QUANT_TBL_PTR quanttbl, int *last_dc_val, int nblocks)
++{
++  block=block; /* unused */
++  quanttbl=quanttbl; /* unused */
++  while (nblocks > 0)
++  {
++    skip_one_block(cinfo,dctbl,actbl,last_dc_val);
++    nblocks--;
+   }
+ }
+ 
++#endif
+ 
+ /*
+- * Finish up at the end of a Huffman-compressed scan.
++ * Initialize for a Huffman-compressed scan.
++ * This is invoked after reading the SOS marker.
+  */
+ 
+ METHODDEF void
+-huff_decoder_term (decompress_info_ptr cinfo)
++huff_decoder_init (decompress_info_ptr cinfo)
+ {
+-  /* No work needed */
+-}
+-
+-
+-/*
+- * The method selection routine for Huffman entropy decoding.
+- */
++  /* Initialize static variables */
++/*  dcinfo = cinfo; */
++  cinfo->bits_left = 0;
+ 
+-GLOBAL void
+-jseldhuffman (decompress_info_ptr cinfo)
+-{
+-  if (! cinfo->arith_code) {
+-    cinfo->methods->entropy_decoder_init = huff_decoder_init;
+-    cinfo->methods->entropy_decode = huff_decode;
+-    cinfo->methods->entropy_decoder_term = huff_decoder_term;
+-  }
+ }
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-3/jinclude.h cvs/h/jinclude
+--- jpeg-3/jinclude.h	1992-03-08 03:01:21.000000000 +0000
++++ cvs/h/jinclude	1996-11-05 09:45:08.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jinclude.h
+  *
+@@ -12,6 +29,10 @@
+  * system include files.
+  */
+ 
++/* RISCOS thing - only allow this file to be included once */
++#ifndef jinclude__
++#define jinclude__
++
+ 
+ /*
+  * Normally the __STDC__ macro can be taken as indicating that the system
+@@ -27,16 +48,6 @@
+ #endif
+ 
+ /*
+- * <stdio.h> is included to get the FILE typedef and NULL macro.
+- * Note that the core portable-JPEG files do not actually do any I/O
+- * using the stdio library; only the user interface, error handler,
+- * and file reading/writing modules invoke any stdio functions.
+- * (Well, we did cheat a bit in jmemmgr.c, but only if MEM_STATS is defined.)
+- */
+-
+-#include <stdio.h>
+-
+-/*
+  * We need the size_t typedef, which defines the parameter type of malloc().
+  * In an ANSI-conforming implementation this is provided by <stdio.h>,
+  * but on non-ANSI systems it's more likely to be in <sys/types.h>.
+@@ -62,17 +73,6 @@
+ #define SIZEOF(object)	((size_t) sizeof(object))
+ 
+ /*
+- * fread() and fwrite() are always invoked through these macros.
+- * On some systems you may need to twiddle the argument casts.
+- * CAUTION: argument order is different from underlying functions!
+- */
+-
+-#define JFREAD(file,buf,sizeofbuf)  \
+-  ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+-#define JFWRITE(file,buf,sizeofbuf)  \
+-  ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+-
+-/*
+  * We need the memcpy() and strcmp() functions, plus memory zeroing.
+  * ANSI and System V implementations declare these in <string.h>.
+  * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
+@@ -81,17 +81,17 @@
+  */
+ 
+ #ifdef INCLUDES_ARE_ANSI
+-#include <string.h>
+-#define MEMZERO(voidptr,size)	memset((voidptr), 0, (size))
++  #include <string.h>
++  #define MEMZERO(voidptr,size)   memset((voidptr), 0, (size))
+ #else /* not ANSI */
+-#ifdef BSD
+-#include <strings.h>
+-#define MEMZERO(voidptr,size)	bzero((voidptr), (size))
+-#define memcpy(dest,src,size)	bcopy((src), (dest), (size))
+-#else /* not BSD, assume Sys V or compatible */
+-#include <string.h>
+-#define MEMZERO(voidptr,size)	memset((voidptr), 0, (size))
+-#endif /* BSD */
++  #ifdef BSD
++    #include <strings.h>
++    #define MEMZERO(voidptr,size)   bzero((voidptr), (size))
++    #define memcpy(dest,src,size)   bcopy((src), (dest), (size))
++  #else /* not BSD, assume Sys V or compatible */
++    #include <string.h>
++    #define MEMZERO(voidptr,size)   memset((voidptr), 0, (size))
++  #endif /* BSD */
+ #endif /* ANSI */
+ 
+ 
+@@ -100,3 +100,29 @@
+ #include "jconfig.h"
+ 
+ #include "jpegdata.h"
++
++/* Assembler coded stuff */
++#ifdef ASMHUFF
++extern void
++asm_huff_decode_blocks(decompress_info_ptr cinfo, JBLOCK block,
++                   HUFF_TBL *dctbl, HUFF_TBL *actbl, QUANT_TBL_PTR quanttbl,
++                   int *last_dc_val, int nblocks);
++
++extern void
++asm_huff_skip_blocks(decompress_info_ptr cinfo, JBLOCK block,
++                 HUFF_TBL *dctbl, HUFF_TBL *actbl, QUANT_TBL_PTR quanttbl,
++                 int *last_dc_val, int nblocks);
++
++extern void panic_exit(int i);
++#endif
++
++extern void asm_j_rev_dct(decompress_info_ptr cinfo, JBLOCK block, int count);
++extern void asm_mono_convert_block(JBLOCK jblock, int *outptr, int outoffset);
++extern void asm_colour_convert_block(JBLOCK jblock, int *outptr, int outoffset);
++extern void asm_colour_convert_block_16(JBLOCK jblock, short int *outptr, int outoffset);
++extern void asm_colour_convert_block_8(JBLOCK jblock, char *outptr, int outoffset);
++extern void asm_diffuse_line_to_8bpp(int *line, int linelength, char *output, char *table32k);
++extern void asm_diffuse_to_8bpp(int *line, int linelength, char *output, char *table32k, int nlines, int linestep, int *palette_data);
++extern char *asm_get_table32k(void);
++
++#endif
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-3/jpegdata.h cvs/h/jpegdata
+--- jpeg-3/jpegdata.h	1992-03-02 18:16:52.000000000 +0000
++++ cvs/h/jpegdata	1996-11-05 09:45:08.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jpegdata.h
+  *
+@@ -6,96 +23,20 @@
+  * For conditions of distribution and use, see the accompanying README file.
+  *
+  * This file defines shared data structures for the various JPEG modules.
+- */
+-
+-
+-/*
+- * You might need to change some of the following declarations if you are
+- * using the JPEG software within a surrounding application program
+- * or porting it to an unusual system.
+- */
+-
+-
+-/* If the source or destination of image data is not to be stdio streams,
+- * these types may need work.  You can replace them with some kind of
+- * pointer or indicator that is useful to you, or just ignore 'em.
+- * Note that the user interface and the various jrdxxx/jwrxxx modules
+- * will also need work for non-stdio input/output.
+- */
+-
+-typedef FILE * JFILEREF;	/* source or dest of JPEG-compressed data */
+-
+-typedef FILE * IFILEREF;	/* source or dest of non-JPEG image data */
+-
+-
+-/* These defines are used in all function definitions and extern declarations.
+- * You could modify them if you need to change function linkage conventions,
+- * as is shown below for use with C++.  Another application would be to make
+- * all functions global for use with code profilers that require it.
+- * NOTE: the C++ test does the right thing if you are reading this include
+- * file in a C++ application to link to JPEG code that's been compiled with a
+- * regular C compiler.  I'm not sure it works if you try to compile the JPEG
+- * code with C++.
++ *
++ * Seriously updated for use deep in RISCOS.
+  */
+ 
+ #define METHODDEF static	/* a function called through method pointers */
+ #define LOCAL	  static	/* a function used only in its module */
+-#define GLOBAL			/* a function referenced thru EXTERNs */
+-#ifdef __cplusplus
+-#define EXTERN	  extern "C"	/* a reference to a GLOBAL function */
+-#else
+-#define EXTERN	  extern	/* a reference to a GLOBAL function */
+-#endif
+-
+-
+-/* Here is the pseudo-keyword for declaring pointers that must be "far"
+- * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
+- * by just saying "FAR *" where such a pointer is needed.  In a few places
+- * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
+- */
+-
+-#ifdef NEED_FAR_POINTERS
+-#define FAR  far
+-#else
++#define GLOBAL    static
++#define EXTERN    static
+ #define FAR
+-#endif
+-
+-
+-
+-/* The remaining declarations are not system-dependent, we hope. */
+-
+-
+-/*
+- * NOTE: if you have an ancient, strict-K&R C compiler, it may choke on the
+- * similarly-named fields in compress_info_struct and decompress_info_struct.
+- * If this happens, you can get around it by rearranging the two structs so
+- * that the similarly-named fields appear first and in the same order in
+- * each struct.  Since such compilers are now pretty rare, we haven't done
+- * this in the portable code, preferring to maintain a logical ordering.
+- */
+-
+-
+-
+-/* This macro is used to declare a "method", that is, a function pointer. */
+-/* We want to supply prototype parameters if the compiler can cope. */
+-/* Note that the arglist parameter must be parenthesized! */
+ 
+-#ifdef PROTO
+ #define METHOD(type,methodname,arglist)  type (*methodname) arglist
+-#else
+-#define METHOD(type,methodname,arglist)  type (*methodname) ()
+-#endif
+-
+-/* Forward references to lists of method pointers */
+-typedef struct external_methods_struct * external_methods_ptr;
+-typedef struct compress_methods_struct * compress_methods_ptr;
+-typedef struct decompress_methods_struct * decompress_methods_ptr;
+-
+ 
+ /* Data structures for images containing either samples or coefficients. */
+ /* Note that the topmost (leftmost) index is always color component. */
+-/* On 80x86 machines, the image arrays are too big for near pointers, */
+-/* but the pointer arrays can fit in near memory. */
+ 
+ typedef JSAMPLE FAR *JSAMPROW;	/* ptr to one image row of pixel samples. */
+ typedef JSAMPROW *JSAMPARRAY;	/* ptr to some rows (a 2-D sample array) */
+@@ -123,9 +62,35 @@ typedef JCOEF FAR *JCOEFPTR;	/* useful i
+ typedef JCOEF DCTELEM;
+ typedef DCTELEM DCTBLOCK[DCTSIZE2];
+ 
++/* -------------------- Statistics on JPEG files ------------------------- */
+ 
+-/* Types for JPEG compression parameters and working tables. */
++#ifdef STATS
++typedef struct
++{
++  int n_jblocks;                  /* JBLOCKs analysed */
++  int n_nonzero_coeff[DCTSIZE2];  /* no of JBLOCKs with this many nonzero coeffs,
++                                     given absolute DC value (not just delta). */
++
++  int n_lines_thismany_nonzero_coeffs_pass1[DCTSIZE]; /* just ac coeffs */
++  int n_lines_thismany_nonzero_coeffs_pass2[DCTSIZE];
++
++  int n_pass1_ac_zero;
++  int n_pass1_ac_dc_zero;
++  int n_pass1_ac_nonzero;
++
++  int n_pass1_even_zero; /* no of rows in pass 1 with even coeffs zero */
++  int n_pass1_odd_zero;
++  int n_pass1_odd_nonzero;
++
++  int higher_coeff_all_zero[DCTSIZE]; /* higher coeffs than this are all zero, in pass 1 */
++
++} stats_struct;
++#define IFSTATS(a) a
++#else
++#define IFSTATS(a)
++#endif
+ 
++/* ----------- Types for JPEG compression parameters and working tables. ---------- */
+ 
+ typedef enum {			/* defines known color spaces */
+ 	CS_UNKNOWN,		/* error/unspecified */
+@@ -141,24 +106,24 @@ typedef struct {		/* Basic info about on
+   /* These values are fixed over the whole image */
+   /* For compression, they must be supplied by the user interface; */
+   /* for decompression, they are read from the SOF marker. */
+-	short component_id;	/* identifier for this component (0..255) */
+-	short component_index;	/* its index in SOF or cinfo->comp_info[] */
+-	short h_samp_factor;	/* horizontal sampling factor (1..4) */
+-	short v_samp_factor;	/* vertical sampling factor (1..4) */
+-	short quant_tbl_no;	/* quantization table selector (0..3) */
++        int /*short*/ component_id;     /* identifier for this component (0..255) */
++        int /*short*/ component_index;  /* its index in SOF or cinfo->comp_info[] */
++        int /*short*/ h_samp_factor;    /* horizontal sampling factor (1..4) */
++        int /*short*/ v_samp_factor;    /* vertical sampling factor (1..4) */
++        int /*short*/ quant_tbl_no;     /* quantization table selector (0..3) */
+   /* These values may vary between scans */
+   /* For compression, they must be supplied by the user interface; */
+   /* for decompression, they are read from the SOS marker. */
+-	short dc_tbl_no;	/* DC entropy table selector (0..3) */
+-	short ac_tbl_no;	/* AC entropy table selector (0..3) */
++        int /*short*/ dc_tbl_no;        /* DC entropy table selector (0..3) */
++        int /*short*/ ac_tbl_no;        /* AC entropy table selector (0..3) */
+   /* These values are computed during compression or decompression startup */
+ 	long true_comp_width;	/* component's image width in samples */
+ 	long true_comp_height;	/* component's image height in samples */
+ 	/* the above are the logical dimensions of the subsampled image */
+   /* These values are computed before starting a scan of the component */
+-	short MCU_width;	/* number of blocks per MCU, horizontally */
+-	short MCU_height;	/* number of blocks per MCU, vertically */
+-	short MCU_blocks;	/* MCU_width * MCU_height */
++        int /*short*/ MCU_width;        /* number of blocks per MCU, horizontally */
++        int /*short*/ MCU_height;       /* number of blocks per MCU, vertically */
++        int /*short*/ MCU_blocks;       /* MCU_width * MCU_height */
+ 	long subsampled_width;	/* image width in samples, after expansion */
+ 	long subsampled_height;	/* image height in samples, after expansion */
+ 	/* the above are the true_comp_xxx values rounded up to multiples of */
+@@ -175,11 +140,7 @@ typedef struct {		/* Basic info about on
+  * quantization values is a significant chunk of the runtime).
+  * Note: the values in a QUANT_TBL are always given in zigzag order.
+  */
+-#ifdef EIGHT_BIT_SAMPLES
+-typedef INT16 QUANT_VAL;	/* element of a quantization table */
+-#else
+-typedef UINT16 QUANT_VAL;	/* element of a quantization table */
+-#endif
++typedef int QUANT_VAL;
+ typedef QUANT_VAL QUANT_TBL[DCTSIZE2];	/* A quantization table */
+ typedef QUANT_VAL * QUANT_TBL_PTR;	/* pointer to same */
+ 
+@@ -189,22 +151,24 @@ typedef struct {		/* A Huffman coding ta
+ 	UINT8 bits[17];		/* bits[k] = # of symbols with codes of */
+ 				/* length k bits; bits[0] is unused */
+ 	UINT8 huffval[256];	/* The symbols, in order of incr code length */
+-  /* This field is used only during compression.  It's initialized FALSE when
+-   * the table is created, and set TRUE when it's been output to the file.
+-   */
+-	boolean sent_table;	/* TRUE when table has been output */
++
+   /* The remaining fields are computed from the above to allow more efficient
+    * coding and decoding.  These fields should be considered private to the
+    * Huffman compression & decompression modules.
+    */
+-	/* encoding tables: */
+-	UINT16 ehufco[256];	/* code for each symbol */
+-	char ehufsi[256];	/* length of code for each symbol */
+ 	/* decoding tables: (element [0] of each array is unused) */
+-	UINT16 mincode[17];	/* smallest code of length k */
++#if 0
++        UINT32 /*UINT16*/ mincode[17];     /* smallest code of length k */
++#endif
+ 	INT32 maxcode[18];	/* largest code of length k (-1 if none) */
+ 	/* (maxcode[17] is a sentinel to ensure huff_DECODE terminates) */
+-	short valptr[17];	/* huffval[] index of 1st symbol of length k */
++        int /*short*/ valptr[17];       /* huffval[] index of 1st symbol of length k */
++                                        /* with value of mincode[k] from above subtracted */
++
++        int shortcut[256]; /* shortcuts the actual reading of huffman values - indexed
++                              by the next 8 bits in the bit stream an entry tells you
++                              how long the next entry is. This allows you to read
++                              the vast majority of huffman codes at a single step. */
+ } HUFF_TBL;
+ 
+ 
+@@ -215,169 +179,70 @@ typedef struct {		/* A Huffman coding ta
+ #define MAX_SAMP_FACTOR     4	/* JPEG limit on sampling factors */
+ #define MAX_BLOCKS_IN_MCU   10	/* JPEG limit on # of blocks in an MCU */
+ 
++/* ----------- Remember a precise position in the huffman stream. ------------------ */
++typedef struct
++{
++  int bit_pointer;   /* (next_input_byte-input_buffer)*32 + bits_left */
++  int get_buffer;
++  short int last_dc_val0; /* NB NOT dequantised */
++  short int last_dc_val1;
++  short int last_dc_val2;
++  short int last_dc_val3; /* in case we ever do CMYK */
++  short int restarts_to_go;
++  short int next_restart_num;
++} huff_pointer;
+ 
+-/* Working data for compression */
+-
+-struct compress_info_struct {
+-/*
+- * All of these fields shall be established by the user interface before
+- * calling jpeg_compress, or by the input_init or c_ui_method_selection
+- * methods.
+- * Most parameters can be set to reasonable defaults by j_c_defaults.
+- * Note that the UI must supply the storage for the main methods struct,
+- * though it sets only a few of the methods there.
+- */
+-	compress_methods_ptr methods; /* Points to list of methods to use */
+-
+-	external_methods_ptr emethods; /* Points to list of methods to use */
+-
+-	IFILEREF input_file;	/* tells input routines where to read image */
+-	JFILEREF output_file;	/* tells output routines where to write JPEG */
+-
+-	long image_width;	/* input image width */
+-	long image_height;	/* input image height */
+-	short input_components;	/* # of color components in input image */
+-
+-	short data_precision;	/* bits of precision in image data */
+-
+-	COLOR_SPACE in_color_space; /* colorspace of input file */
+-	COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */
+-
+-	double input_gamma;	/* image gamma of input file */
+-
+-	boolean write_JFIF_header; /* should a JFIF marker be written? */
+-	/* These three values are not used by the JPEG code, only copied */
+-	/* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
+-	/* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
+-	/* ratio is defined by X_density/Y_density even when density_unit=0. */
+-	UINT8 density_unit;	/* JFIF code for pixel size units */
+-	UINT16 X_density;	/* Horizontal pixel density */
+-	UINT16 Y_density;	/* Vertical pixel density */
+-
+-	short num_components;	/* # of color components in JPEG image */
+-	jpeg_component_info * comp_info;
+-	/* comp_info[i] describes component that appears i'th in SOF */
+-
+-	QUANT_TBL_PTR quant_tbl_ptrs[NUM_QUANT_TBLS];
+-	/* ptrs to coefficient quantization tables, or NULL if not defined */
+-
+-	HUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+-	HUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+-	/* ptrs to Huffman coding tables, or NULL if not defined */
+-
+-	UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arithmetic-coding tables */
+-	UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arithmetic-coding tables */
+-	UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arithmetic-coding tables */
+-
+-	boolean arith_code;	/* TRUE=arithmetic coding, FALSE=Huffman */
+-	boolean interleave;	/* TRUE=interleaved output, FALSE=not */
+-	boolean optimize_coding; /* TRUE=optimize entropy encoding parms */
+-	boolean CCIR601_sampling; /* TRUE=first samples are cosited */
+-
+-	UINT16 restart_interval;/* MDUs per restart interval, or 0 for no restart */
+-
+-/*
+- * These fields are computed during jpeg_compress startup
+- */
+-	short max_h_samp_factor; /* largest h_samp_factor */
+-	short max_v_samp_factor; /* largest v_samp_factor */
+-
+-/*
+- * These fields may be useful for progress monitoring
+- */
+-
+-	int total_passes;	/* number of passes expected */
+-	int completed_passes;	/* number of passes completed so far */
+-
+-/*
+- * These fields are valid during any one scan
+- */
+-	short comps_in_scan;	/* # of JPEG components output this time */
+-	jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+-	/* *cur_comp_info[i] describes component that appears i'th in SOS */
+-
+-	long MCUs_per_row;	/* # of MCUs across the image */
+-	long MCU_rows_in_scan;	/* # of MCU rows in the image */
+-
+-	short blocks_in_MCU;	/* # of DCT blocks per MCU */
+-	short MCU_membership[MAX_BLOCKS_IN_MCU];
+-	/* MCU_membership[i] is index in cur_comp_info of component owning */
+-	/* i'th block in an MCU */
+-
+-	/* these fields are private data for the entropy encoder */
+-	JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp */
+-	JCOEF last_dc_diff[MAX_COMPS_IN_SCAN]; /* last DC diff for each comp */
+-	UINT16 restarts_to_go;	/* MDUs left in this restart interval */
+-	short next_restart_num;	/* # of next RSTn marker (0..7) */
+-};
+-
+-typedef struct compress_info_struct * compress_info_ptr;
+-
++/* ------------- Error codes for various forms of unacceptable JPEG file ------------- */
++#define E_PRE_NOT_8         1            /* Data precision not 8 */
++#define E_RESTART           2            /* Restart interval not 0 */
++#define E_MULTI_SCAN        3            /* Multi-scan file */
++#define E_TOO_HIGH          4            /* Image too high, max is %i pixels */
++#define E_BAD_SAMPLE        5            /* Bad sample factor */
++#define E_HEIGHT            6            /* Height is %i, not as specified */
++#define E_WIDTH             7            /* Width is %i, not as specified */
++#define E_COLOUR            8            /* Bad colour space (%i), not grey or YUV */
++#define E_COMPONENTS        9            /* Bad number (%i) of components, only 1 or 3 allowed */
++#define E_TOO_WIDE          10           /* Image too wide, max is %i pixels */
+ 
+-/* Working data for decompression */
++/* ------------- Working data for decompression ---------------------------------- */
+ 
+ struct decompress_info_struct {
+-/*
+- * These fields shall be established by the user interface before
+- * calling jpeg_decompress.
+- * Most parameters can be set to reasonable defaults by j_d_defaults.
+- * Note that the UI must supply the storage for the main methods struct,
+- * though it sets only a few of the methods there.
+- */
+-	decompress_methods_ptr methods; /* Points to list of methods to use */
+-
+-	external_methods_ptr emethods; /* Points to list of methods to use */
+ 
+-	JFILEREF input_file;	/* tells input routines where to read JPEG */
+-	IFILEREF output_file;	/* tells output routines where to write image */
+-
+-	/* these can be set at d_ui_method_selection time: */
++        int error_code;         /* Returned err code, 0 if no error */
++        int error_argument1;    /* Supplementary error data */
++        int error_argument2;    /* Supplementary error data */
+ 
+-	COLOR_SPACE out_color_space; /* colorspace of output */
++        char *workspace_UNUSED;        /* For band buffer and things. (no, implicitly at end of this space now) */
++        int workspace_size;     /* number of bytes */
++/* up to here appears in sources.SprExtend */
+ 
+-	double output_gamma;	/* image gamma wanted in output */
++        int /*long*/ image_width;       /* overall image width */
++        int /*long*/ image_height;      /* overall image height */
++        COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */
++/* up to here is replicated somewhat in CFSI-JPEG's interface */
+ 
+-	boolean quantize_colors; /* T if output is a colormapped format */
+-	/* the following are ignored if not quantize_colors: */
+-	boolean two_pass_quantize;	/* use two-pass color quantization? */
+-	boolean use_dithering;		/* want color dithering? */
+-	int desired_number_of_colors;	/* max number of colors to use */
++        char *table32k; /* the 16bpp->8bpp 32K lookup table, if you need it. */
++        BOOL table32k_unavailable; /* Set if we ever failed to get table32k.
++                                   This means we're probably on an old OS, so the
++                                   table will never be available. */
+ 
+-	boolean do_block_smoothing; /* T = apply cross-block smoothing */
+-	boolean do_pixel_smoothing; /* T = apply post-subsampling smoothing */
++        int *band_buffer; /* Large buffer into which the colour data goes. */
++                          /* We construct one strip, 8 or 16 pixels high, across the image. */
++        int band_buffer_size; /* Must be a multiple of 16 */
+ 
+-/*
+- * These fields are used for efficient buffering of data between read_jpeg_data
+- * and the entropy decoding object.  By using a shared buffer, we avoid copying
+- * data and eliminate the need for an "unget" operation at the end of a scan.
+- * The actual source of the data is known only to read_jpeg_data; see the
+- * JGETC macro, below.
+- * Note: the user interface is expected to allocate the input_buffer and
+- * initialize bytes_in_buffer to 0.  Also, for JFIF/raw-JPEG input, the UI
+- * actually supplies the read_jpeg_data method.  This is all handled by
+- * j_d_defaults in a typical implementation.
+- */
+ 	char * input_buffer;	/* start of buffer (private to input code) */
+ 	char * next_input_byte;	/* => next byte to read from buffer */
+-	int bytes_in_buffer;	/* # of bytes remaining in buffer */
+-
+-/*
+- * These fields are set by read_file_header or read_scan_header
+- */
+-	long image_width;	/* overall image width */
+-	long image_height;	/* overall image height */
+-
+-	short data_precision;	/* bits of precision in image data */
++        char * buffer_end;      /* pointer to end of buffer */
+ 
+-	COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */
++        int data_precision;   /* bits of precision in image data */
+ 
+         /* These three values are not used by the JPEG code, merely copied */
+ 	/* from the JFIF APP0 marker (if any). */
+-	UINT8 density_unit;	/* JFIF code for pixel size units */
+-	UINT16 X_density;	/* Horizontal pixel density */
+-	UINT16 Y_density;	/* Vertical pixel density */
++        UINT32 /*UINT8*/ density_unit;     /* JFIF code for pixel size units */
++        UINT32 /*UINT16*/ X_density;       /* Horizontal pixel density */
++        UINT32 /*UINT16*/ Y_density;       /* Vertical pixel density */
+ 
+-	short num_components;	/* # of color components in JPEG image */
++        int /*short*/ num_components;   /* # of color components in JPEG image */
+ 	jpeg_component_info * comp_info;
+ 	/* comp_info[i] describes component that appears i'th in SOF */
+ 
+@@ -395,462 +260,113 @@ struct decompress_info_struct {
+ 	boolean arith_code;	/* TRUE=arithmetic coding, FALSE=Huffman */
+ 	boolean CCIR601_sampling; /* TRUE=first samples are cosited */
+ 
+-	UINT16 restart_interval;/* MDUs per restart interval, or 0 for no restart */
+-
+-/*
+- * These fields are computed during jpeg_decompress startup
+- */
+-	short max_h_samp_factor; /* largest h_samp_factor */
+-	short max_v_samp_factor; /* largest v_samp_factor */
+-
+-	short color_out_comps;	/* # of color components output by color_convert */
+-				/* (need not match num_components) */
+-	short final_out_comps;	/* # of color components sent to put_pixel_rows */
+-	/* (1 when quantizing colors, else same as color_out_comps) */
+-
+-/*
+- * When quantizing colors, the color quantizer leaves a pointer to the output
+- * colormap in these fields.  The colormap is valid from the time put_color_map
+- * is called (must be before any put_pixel_rows calls) until shutdown (more
+- * specifically, until free_all is called to release memory).
+- */
+-	int actual_number_of_colors; /* actual number of entries */
+-	JSAMPARRAY colormap;	/* NULL if not valid */
+-	/* map has color_out_comps rows * actual_number_of_colors columns */
+-
+-/*
+- * These fields may be useful for progress monitoring
+- */
+-
+-	int total_passes;	/* number of passes expected */
+-	int completed_passes;	/* number of passes completed so far */
++        UINT32 /*UINT16*/ restart_interval;/* MDUs per restart interval, or 0 for no restart */
++        int restarts_to_go;
++        int next_restart_num;
+ 
+ /*
+  * These fields are valid during any one scan
+  */
+-	short comps_in_scan;	/* # of JPEG components input this time */
++        int /*short*/ comps_in_scan;    /* # of JPEG components input this time */
+ 	jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+ 	/* *cur_comp_info[i] describes component that appears i'th in SOS */
+ 
+ 	long MCUs_per_row;	/* # of MCUs across the image */
+ 	long MCU_rows_in_scan;	/* # of MCU rows in the image */
+ 
+-	short blocks_in_MCU;	/* # of DCT blocks per MCU */
+-	short MCU_membership[MAX_BLOCKS_IN_MCU];
+-	/* MCU_membership[i] is index in cur_comp_info of component owning */
+-	/* i'th block in an MCU */
+-
+ 	/* these fields are private data for the entropy encoder */
+-	JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp */
+-	JCOEF last_dc_diff[MAX_COMPS_IN_SCAN]; /* last DC diff for each comp */
+-	UINT16 restarts_to_go;	/* MDUs left in this restart interval */
+-	short next_restart_num;	/* # of next RSTn marker (0..7) */
+-};
+-
+-typedef struct decompress_info_struct * decompress_info_ptr;
+-
+-
+-/* Macros for reading data from the decompression input buffer */
+-
+-#ifdef CHAR_IS_UNSIGNED
+-#define JGETC(cinfo)	( --(cinfo)->bytes_in_buffer < 0 ? \
+-			 (*(cinfo)->methods->read_jpeg_data) (cinfo) : \
+-			 (int) (*(cinfo)->next_input_byte++) )
+-#else
+-#define JGETC(cinfo)	( --(cinfo)->bytes_in_buffer < 0 ? \
+-			 (*(cinfo)->methods->read_jpeg_data) (cinfo) : \
+-			 (int) (*(cinfo)->next_input_byte++) & 0xFF )
+-#endif
+-
+-#define JUNGETC(ch,cinfo)  ((cinfo)->bytes_in_buffer++, \
+-			    *(--((cinfo)->next_input_byte)) = (ch))
+-
+-#define MIN_UNGET	4	/* may always do at least 4 JUNGETCs */
+-
+-
+-/* A virtual image has a control block whose contents are private to the
+- * memory manager module (and may differ between managers).  The rest of the
+- * code only refers to virtual images by these pointer types, and never
+- * dereferences the pointer.
+- */
+-
+-typedef struct big_sarray_control * big_sarray_ptr;
+-typedef struct big_barray_control * big_barray_ptr;
+-
+-/* Although a real ANSI C compiler can deal perfectly well with pointers to
+- * unspecified structures (see "incomplete types" in the spec), a few pre-ANSI
+- * and pseudo-ANSI compilers get confused.  To keep one of these bozos happy,
+- * add -DINCOMPLETE_TYPES_BROKEN to CFLAGS in your Makefile.  Then we will
+- * pseudo-define the structs as containing a single "dummy" field.
+- * The memory managers #define AM_MEMORY_MANAGER before including this file,
+- * so that they can make their own definitions of the structs.
+- */
+-
+-#ifdef INCOMPLETE_TYPES_BROKEN
+-#ifndef AM_MEMORY_MANAGER
+-struct big_sarray_control { long dummy; };
+-struct big_barray_control { long dummy; };
+-#endif
+-#endif
+-
+-
+-/* Method types that need typedefs */
+-
+-typedef METHOD(void, MCU_output_method_ptr, (compress_info_ptr cinfo,
+-					     JBLOCK *MCU_data));
+-typedef METHOD(void, MCU_output_caller_ptr, (compress_info_ptr cinfo,
+-					     MCU_output_method_ptr output_method));
+-typedef METHOD(void, subsample_ptr, (compress_info_ptr cinfo,
+-				     int which_component,
+-				     long input_cols, int input_rows,
+-				     long output_cols, int output_rows,
+-				     JSAMPARRAY above,
+-				     JSAMPARRAY input_data,
+-				     JSAMPARRAY below,
+-				     JSAMPARRAY output_data));
+-typedef METHOD(void, unsubsample_ptr, (decompress_info_ptr cinfo,
+-				       int which_component,
+-				       long input_cols, int input_rows,
+-				       long output_cols, int output_rows,
+-				       JSAMPARRAY above,
+-				       JSAMPARRAY input_data,
+-				       JSAMPARRAY below,
+-				       JSAMPARRAY output_data));
+-typedef METHOD(void, quantize_method_ptr, (decompress_info_ptr cinfo,
+-					   int num_rows,
+-					   JSAMPIMAGE input_data,
+-					   JSAMPARRAY output_workspace));
+-typedef METHOD(void, quantize_caller_ptr, (decompress_info_ptr cinfo,
+-					   quantize_method_ptr quantize_method));
++        JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp - NOT dequantized yet */
+ 
++        int current_huff_pointer; /* Currently loaded band, or -1 if none. */
++        int xmin;
++        int xmax;                 /* Min and max x pixels required: clip as early
++                                  as possible. */
++        int options;
+ 
+-/* These structs contain function pointers for the various JPEG methods. */
++        /* Statics moved in from the huffman decoding */
++        int get_buffer;
++        int bits_left;
+ 
+-/* Routines to be provided by the surrounding application, rather than the
+- * portable JPEG code proper.  These are the same for compression and
+- * decompression.
+- */
++        /* Random check words to look for the same sprite over again */
++        int check1;
++        int check2;
++        int check3;
+ 
+-struct external_methods_struct {
+-	/* User interface: error exit and trace message routines */
+-	/* NOTE: the string msgtext parameters will eventually be replaced */
+-	/* by an enumerated-type code so that non-English error messages */
+-	/* can be substituted easily.  This will not be done until all the */
+-	/* code is in place, so that we know what messages are needed. */
+-	METHOD(void, error_exit, (const char *msgtext));
+-	METHOD(void, trace_message, (const char *msgtext));
++        IFSTATS(stats_struct stats;)       /* Gathering statistics */
+ 
+-	/* Working data for error/trace facility */
+-	/* See macros below for the usage of these variables */
+-	int trace_level;	/* level of detail of tracing messages */
+-	/* Use level 0 for unsuppressable messages (nonfatal errors) */
+-	/* Use levels 1, 2, 3 for successively more detailed trace options */
++        JBLOCK jblocks[7]; /* YYYYUV blocks, and one spare at the front */
+ 
+-	int message_parm[8];	/* store numeric parms for messages here */
++#define HPOINTERS 200 /* max picture depth 16*this for colour, 8*this for mono, in pixels */
++        huff_pointer *huff_pointers;
++                      /* An array of information every 16 pixel lines, which
++                      allows us to start decoding the file at that point. This
++                      allows reasonably quick random access to anywhere in the file. */
+ 
+-	/* Memory management */
+-	/* NB: alloc routines never return NULL. They exit to */
+-	/* error_exit if not successful. */
+-	METHOD(void *, alloc_small, (size_t sizeofobject));
+-	METHOD(void, free_small, (void *ptr));
+-	METHOD(void FAR *, alloc_medium, (size_t sizeofobject));
+-	METHOD(void, free_medium, (void FAR *ptr));
+-	METHOD(JSAMPARRAY, alloc_small_sarray, (long samplesperrow,
+-						long numrows));
+-	METHOD(void, free_small_sarray, (JSAMPARRAY ptr));
+-	METHOD(JBLOCKARRAY, alloc_small_barray, (long blocksperrow,
+-						 long numrows));
+-	METHOD(void, free_small_barray, (JBLOCKARRAY ptr));
+-	METHOD(big_sarray_ptr, request_big_sarray, (long samplesperrow,
+-						    long numrows,
+-						    long unitheight));
+-	METHOD(big_barray_ptr, request_big_barray, (long blocksperrow,
+-						    long numrows,
+-						    long unitheight));
+-	METHOD(void, alloc_big_arrays, (long extra_small_samples,
+-					long extra_small_blocks,
+-					long extra_medium_space));
+-	METHOD(JSAMPARRAY, access_big_sarray, (big_sarray_ptr ptr,
+-					       long start_row,
+-					       boolean writable));
+-	METHOD(JBLOCKARRAY, access_big_barray, (big_barray_ptr ptr,
+-						long start_row,
+-						boolean writable));
+-	METHOD(void, free_big_sarray, (big_sarray_ptr ptr));
+-	METHOD(void, free_big_barray, (big_barray_ptr ptr));
+-	METHOD(void, free_all, (void));
++        /* Space always needed, and pointed at by some of the pointers above. */
+ 
+-	long max_memory_to_use;	/* maximum amount of memory to use */
++        jpeg_component_info s_cur_comp_info[MAX_COMPS_IN_SCAN];
++        QUANT_TBL s_quant_tbl[NUM_QUANT_TBLS];
++        HUFF_TBL s_dc_huff_tbl[NUM_HUFF_TBLS];
++        HUFF_TBL s_ac_huff_tbl[NUM_HUFF_TBLS];
+ };
+ 
+-/* Macros to simplify using the error and trace message stuff */
+-/* The first parameter is generally cinfo->emethods */
+-
+-#define ERREXIT(emeth,msg)		((*(emeth)->error_exit) (msg))
+-#define ERREXIT1(emeth,msg,p1)		((emeth)->message_parm[0] = (p1), \
+-					 (*(emeth)->error_exit) (msg))
+-#define ERREXIT2(emeth,msg,p1,p2)	((emeth)->message_parm[0] = (p1), \
+-					 (emeth)->message_parm[1] = (p2), \
+-					 (*(emeth)->error_exit) (msg))
+-#define ERREXIT3(emeth,msg,p1,p2,p3)	((emeth)->message_parm[0] = (p1), \
+-					 (emeth)->message_parm[1] = (p2), \
+-					 (emeth)->message_parm[2] = (p3), \
+-					 (*(emeth)->error_exit) (msg))
+-#define ERREXIT4(emeth,msg,p1,p2,p3,p4) ((emeth)->message_parm[0] = (p1), \
+-					 (emeth)->message_parm[1] = (p2), \
+-					 (emeth)->message_parm[2] = (p3), \
+-					 (emeth)->message_parm[3] = (p4), \
+-					 (*(emeth)->error_exit) (msg))
+-
+-#define MAKESTMT(stuff)		do { stuff } while (0)
+-
+-#define TRACEMS(emeth,lvl,msg)    \
+-  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
+-		(*(emeth)->trace_message) (msg); } )
+-#define TRACEMS1(emeth,lvl,msg,p1)    \
+-  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
+-		(emeth)->message_parm[0] = (p1); \
+-		(*(emeth)->trace_message) (msg); } )
+-#define TRACEMS2(emeth,lvl,msg,p1,p2)    \
+-  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
+-		(emeth)->message_parm[0] = (p1); \
+-		(emeth)->message_parm[1] = (p2); \
+-		(*(emeth)->trace_message) (msg); } )
+-#define TRACEMS3(emeth,lvl,msg,p1,p2,p3)    \
+-  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
+-		int * _mp = (emeth)->message_parm; \
+-		*_mp++ = (p1); *_mp++ = (p2); *_mp = (p3); \
+-		(*(emeth)->trace_message) (msg); } )
+-#define TRACEMS4(emeth,lvl,msg,p1,p2,p3,p4)    \
+-  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
+-		int * _mp = (emeth)->message_parm; \
+-		*_mp++ = (p1); *_mp++ = (p2); *_mp++ = (p3); *_mp = (p4); \
+-		(*(emeth)->trace_message) (msg); } )
+-#define TRACEMS8(emeth,lvl,msg,p1,p2,p3,p4,p5,p6,p7,p8)    \
+-  MAKESTMT( if ((emeth)->trace_level >= (lvl)) { \
+-		int * _mp = (emeth)->message_parm; \
+-		*_mp++ = (p1); *_mp++ = (p2); *_mp++ = (p3); *_mp++ = (p4); \
+-		*_mp++ = (p5); *_mp++ = (p6); *_mp++ = (p7); *_mp = (p8); \
+-		(*(emeth)->trace_message) (msg); } )
+-
+-
+-/* Methods used during JPEG compression. */
++typedef struct decompress_info_struct * decompress_info_ptr;
+ 
+-struct compress_methods_struct {
+-	/* Hook for user interface to get control after input_init */
+-	METHOD(void, c_ui_method_selection, (compress_info_ptr cinfo));
+-	/* Hook for user interface to do progress monitoring */
+-	METHOD(void, progress_monitor, (compress_info_ptr cinfo,
+-					long loopcounter, long looplimit));
+-	/* Input image reading & conversion to standard form */
+-	METHOD(void, input_init, (compress_info_ptr cinfo));
+-	METHOD(void, get_input_row, (compress_info_ptr cinfo,
+-				     JSAMPARRAY pixel_row));
+-	METHOD(void, input_term, (compress_info_ptr cinfo));
+-	/* Color space and gamma conversion */
+-	METHOD(void, colorin_init, (compress_info_ptr cinfo));
+-	METHOD(void, get_sample_rows, (compress_info_ptr cinfo,
+-				       int rows_to_read,
+-				       JSAMPIMAGE image_data));
+-	METHOD(void, colorin_term, (compress_info_ptr cinfo));
+-	/* Expand picture data at edges */
+-	METHOD(void, edge_expand, (compress_info_ptr cinfo,
+-				   long input_cols, int input_rows,
+-				   long output_cols, int output_rows,
+-				   JSAMPIMAGE image_data));
+-	/* Subsample pixel values of a single component */
+-	/* There can be a different subsample method for each component */
+-	METHOD(void, subsample_init, (compress_info_ptr cinfo));
+-	subsample_ptr subsample[MAX_COMPS_IN_SCAN];
+-	METHOD(void, subsample_term, (compress_info_ptr cinfo));
+-	/* Extract samples in MCU order, process & hand off to output_method */
+-	/* The input is always exactly N MCU rows worth of data */
+-	METHOD(void, extract_init, (compress_info_ptr cinfo));
+-	METHOD(void, extract_MCUs, (compress_info_ptr cinfo,
+-				    JSAMPIMAGE image_data,
+-				    int num_mcu_rows,
+-				    MCU_output_method_ptr output_method));
+-	METHOD(void, extract_term, (compress_info_ptr cinfo));
+-	/* Entropy encoding parameter optimization */
+-	METHOD(void, entropy_optimize, (compress_info_ptr cinfo,
+-					MCU_output_caller_ptr source_method));
+-	/* Entropy encoding */
+-	METHOD(void, entropy_encoder_init, (compress_info_ptr cinfo));
+-	METHOD(void, entropy_encode, (compress_info_ptr cinfo,
+-				      JBLOCK *MCU_data));
+-	METHOD(void, entropy_encoder_term, (compress_info_ptr cinfo));
+-	/* JPEG file header construction */
+-	METHOD(void, write_file_header, (compress_info_ptr cinfo));
+-	METHOD(void, write_scan_header, (compress_info_ptr cinfo));
+-	METHOD(void, write_jpeg_data, (compress_info_ptr cinfo,
+-				       char *dataptr,
+-				       int datacount));
+-	METHOD(void, write_scan_trailer, (compress_info_ptr cinfo));
+-	METHOD(void, write_file_trailer, (compress_info_ptr cinfo));
+-	/* Pipeline control */
+-	METHOD(void, c_pipeline_controller, (compress_info_ptr cinfo));
+-	METHOD(void, entropy_output, (compress_info_ptr cinfo,
+-				      char *dataptr,
+-				      int datacount));
+-	/* Overall control */
+-	METHOD(void, c_per_scan_method_selection, (compress_info_ptr cinfo));
+-};
+ 
+-/* Methods used during JPEG decompression. */
++/* Macros for reading data from the decompression input buffer */
+ 
+-struct decompress_methods_struct {
+-	/* Hook for user interface to get control after reading file header */
+-	METHOD(void, d_ui_method_selection, (decompress_info_ptr cinfo));
+-	/* Hook for user interface to do progress monitoring */
+-	METHOD(void, progress_monitor, (decompress_info_ptr cinfo,
+-					long loopcounter, long looplimit));
+-	/* JPEG file scanning */
+-	METHOD(void, read_file_header, (decompress_info_ptr cinfo));
+-	METHOD(boolean, read_scan_header, (decompress_info_ptr cinfo));
+-	METHOD(int, read_jpeg_data, (decompress_info_ptr cinfo));
+-	METHOD(void, read_scan_trailer, (decompress_info_ptr cinfo));
+-	METHOD(void, read_file_trailer, (decompress_info_ptr cinfo));
+-	/* Entropy decoding */
+-	METHOD(void, entropy_decoder_init, (decompress_info_ptr cinfo));
+-	METHOD(void, entropy_decode, (decompress_info_ptr cinfo,
+-				      JBLOCK *MCU_data));
+-	METHOD(void, entropy_decoder_term, (decompress_info_ptr cinfo));
+-	/* MCU disassembly: fetch MCUs from entropy_decode, build coef array */
+-	/* The reverse_DCT step is in the same module for symmetry reasons */
+-	METHOD(void, disassemble_init, (decompress_info_ptr cinfo));
+-	METHOD(void, disassemble_MCU, (decompress_info_ptr cinfo,
+-				       JBLOCKIMAGE image_data));
+-	METHOD(void, reverse_DCT, (decompress_info_ptr cinfo,
+-				   JBLOCKIMAGE coeff_data,
+-				   JSAMPIMAGE output_data, int start_row));
+-	METHOD(void, disassemble_term, (decompress_info_ptr cinfo));
+-	/* Cross-block smoothing */
+-	METHOD(void, smooth_coefficients, (decompress_info_ptr cinfo,
+-					   jpeg_component_info *compptr,
+-					   JBLOCKROW above,
+-					   JBLOCKROW currow,
+-					   JBLOCKROW below,
+-					   JBLOCKROW output));
+-	/* Un-subsample pixel values of a single component */
+-	/* There can be a different unsubsample method for each component */
+-	METHOD(void, unsubsample_init, (decompress_info_ptr cinfo));
+-	unsubsample_ptr unsubsample[MAX_COMPS_IN_SCAN];
+-	METHOD(void, unsubsample_term, (decompress_info_ptr cinfo));
+-	/* Color space and gamma conversion */
+-	METHOD(void, colorout_init, (decompress_info_ptr cinfo));
+-	METHOD(void, color_convert, (decompress_info_ptr cinfo,
+-				     int num_rows, long num_cols,
+-				     JSAMPIMAGE input_data,
+-				     JSAMPIMAGE output_data));
+-	METHOD(void, colorout_term, (decompress_info_ptr cinfo));
+-	/* Color quantization */
+-	METHOD(void, color_quant_init, (decompress_info_ptr cinfo));
+-	METHOD(void, color_quantize, (decompress_info_ptr cinfo,
+-				      int num_rows,
+-				      JSAMPIMAGE input_data,
+-				      JSAMPARRAY output_data));
+-	METHOD(void, color_quant_prescan, (decompress_info_ptr cinfo,
+-					   int num_rows,
+-					   JSAMPIMAGE image_data,
+-					   JSAMPARRAY workspace));
+-	METHOD(void, color_quant_doit, (decompress_info_ptr cinfo,
+-					quantize_caller_ptr source_method));
+-	METHOD(void, color_quant_term, (decompress_info_ptr cinfo));
+-	/* Output image writing */
+-	METHOD(void, output_init, (decompress_info_ptr cinfo));
+-	METHOD(void, put_color_map, (decompress_info_ptr cinfo,
+-				     int num_colors, JSAMPARRAY colormap));
+-	METHOD(void, put_pixel_rows, (decompress_info_ptr cinfo,
+-				      int num_rows,
+-				      JSAMPIMAGE pixel_data));
+-	METHOD(void, output_term, (decompress_info_ptr cinfo));
+-	/* Pipeline control */
+-	METHOD(void, d_pipeline_controller, (decompress_info_ptr cinfo));
+-	/* Overall control */
+-	METHOD(void, d_per_scan_method_selection, (decompress_info_ptr cinfo));
+-};
++/* The buffer contains the entire file */
++#define JGETC(cinfo) (int) ((cinfo)->next_input_byte >= (cinfo)->buffer_end ? 255 : *(cinfo)->next_input_byte++)
+ 
++/* Macros to simplify using the error and trace message stuff */
++/* The first parameter is generally cinfo->emethods, left undisturbed in
++   c.jrdjfif but not used here. */
+ 
+-/* External declarations for routines that aren't called via method ptrs. */
+-/* Note: use "j" as first char of names to minimize namespace pollution. */
+-/* The PP macro hides prototype parameters from compilers that can't cope. */
++/* The variable FILE_ is used to identify source files, smaller than __FILE__ (a bit!) for
++non-debugging code. */
++#define EXIT exit(FILE_+__LINE__);
+ 
+-#ifdef PROTO
+-#define PP(arglist)	arglist
++#ifdef DEBUG
++  #ifdef EMBED
++    #define TRACEMS(emeth,lvl,msg) {sprintf(0, msg); newline();}
++    #define TRACEMS1(emeth,lvl,msg,p1) {sprintf(0, msg,p1); newline();}
++    #define TRACEMS2(emeth,lvl,msg,p1,p2) {sprintf(0, msg,p1,p2); newline();}
++    #define TRACEMS3(emeth,lvl,msg,p1,p2,p3) {sprintf(0, msg,p1,p2,p3); newline();}
++    #define TRACEMS4(emeth,lvl,msg,p1,p2,p3,p4) {sprintf(0, msg,p1,p2,p3,p4); newline();}
++    #define TRACEMS8(emeth,lvl,msg,p1,p2,p3,p4,p5,p6,p7,p8) {sprintf(0, msg,p1,p2,p3,p4,p5,p6,p7,p8); newline();}
++  #else
++    #define TRACEMS(emeth,lvl,msg) {if (verbose) {printf(msg); printf("\n");}}
++    #define TRACEMS1(emeth,lvl,msg,p1) {if (verbose) {printf(msg,p1); printf("\n");}}
++    #define TRACEMS2(emeth,lvl,msg,p1,p2) {if (verbose) {printf(msg,p1,p2); printf("\n");}}
++    #define TRACEMS3(emeth,lvl,msg,p1,p2,p3) {if (verbose) {printf(msg,p1,p2,p3); printf("\n");}}
++    #define TRACEMS4(emeth,lvl,msg,p1,p2,p3,p4) {if (verbose) {printf(msg,p1,p2,p3,p4); printf("\n");}}
++    #define TRACEMS8(emeth,lvl,msg,p1,p2,p3,p4,p5,p6,p7,p8) {if (verbose) {printf(msg,p1,p2,p3,p4,p5,p6,p7,p8); printf("\n");}}
++  #endif
+ #else
+-#define PP(arglist)	()
++  #define TRACEMS(emeth,lvl,msg)
++  #define TRACEMS1(emeth,lvl,msg,p1)
++  #define TRACEMS2(emeth,lvl,msg,p1,p2)
++  #define TRACEMS3(emeth,lvl,msg,p1,p2,p3)
++  #define TRACEMS4(emeth,lvl,msg,p1,p2,p3,p4)
++  #define TRACEMS8(emeth,lvl,msg,p1,p2,p3,p4,p5,p6,p7,p8)
+ #endif
+ 
++#define DUMPVAL(x) tracef(#x "=0x%x " _ (int)(x));
++#define DUMPVALN(x) tracef(#x "=0x%x\n" _ (int)(x));
+ 
+-/* main entry for compression */
+-EXTERN void jpeg_compress PP((compress_info_ptr cinfo));
+-
+-/* default parameter setup for compression */
+-EXTERN void j_c_defaults PP((compress_info_ptr cinfo, int quality,
+-			     boolean force_baseline));
+-EXTERN void j_monochrome_default PP((compress_info_ptr cinfo));
+-EXTERN void j_set_quality PP((compress_info_ptr cinfo, int quality,
+-			      boolean force_baseline));
+-
+-/* main entry for decompression */
+-EXTERN void jpeg_decompress PP((decompress_info_ptr cinfo));
+-
+-/* default parameter setup for decompression */
+-EXTERN void j_d_defaults PP((decompress_info_ptr cinfo,
+-			     boolean standard_buffering));
+-
+-/* forward DCT */
+-EXTERN void j_fwd_dct PP((DCTBLOCK data));
+-/* inverse DCT */
+-EXTERN void j_rev_dct PP((DCTBLOCK data));
+-
+-/* utility routines in jutils.c */
+-EXTERN long jround_up PP((long a, long b));
+-EXTERN void jcopy_sample_rows PP((JSAMPARRAY input_array, int source_row,
+-				  JSAMPARRAY output_array, int dest_row,
+-				  int num_rows, long num_cols));
+-EXTERN void jcopy_block_row PP((JBLOCKROW input_row, JBLOCKROW output_row,
+-				long num_blocks));
+-EXTERN void jzero_far PP((void FAR * target, size_t bytestozero));
+-
+-/* method selection routines for compression modules */
+-EXTERN void jselcpipeline PP((compress_info_ptr cinfo)); /* jcpipe.c */
+-EXTERN void jselchuffman PP((compress_info_ptr cinfo)); /* jchuff.c */
+-EXTERN void jselcarithmetic PP((compress_info_ptr cinfo)); /* jcarith.c */
+-EXTERN void jselexpand PP((compress_info_ptr cinfo)); /* jcexpand.c */
+-EXTERN void jselsubsample PP((compress_info_ptr cinfo)); /* jcsample.c */
+-EXTERN void jselcmcu PP((compress_info_ptr cinfo)); /* jcmcu.c */
+-EXTERN void jselccolor PP((compress_info_ptr cinfo));	/* jccolor.c */
+-/* The user interface should call one of these to select input format: */
+-EXTERN void jselrgif PP((compress_info_ptr cinfo)); /* jrdgif.c */
+-EXTERN void jselrppm PP((compress_info_ptr cinfo)); /* jrdppm.c */
+-EXTERN void jselrrle PP((compress_info_ptr cinfo)); /* jrdrle.c */
+-EXTERN void jselrtarga PP((compress_info_ptr cinfo)); /* jrdtarga.c */
+-/* and one of these to select output header format: */
+-EXTERN void jselwjfif PP((compress_info_ptr cinfo)); /* jwrjfif.c */
+-
+-/* method selection routines for decompression modules */
+-EXTERN void jseldpipeline PP((decompress_info_ptr cinfo)); /* jdpipe.c */
+-EXTERN void jseldhuffman PP((decompress_info_ptr cinfo)); /* jdhuff.c */
+-EXTERN void jseldarithmetic PP((decompress_info_ptr cinfo)); /* jdarith.c */
+-EXTERN void jseldmcu PP((decompress_info_ptr cinfo)); /* jdmcu.c */
+-EXTERN void jselbsmooth PP((decompress_info_ptr cinfo)); /* jbsmooth.c */
+-EXTERN void jselunsubsample PP((decompress_info_ptr cinfo)); /* jdsample.c */
+-EXTERN void jseldcolor PP((decompress_info_ptr cinfo));	/* jdcolor.c */
+-EXTERN void jsel1quantize PP((decompress_info_ptr cinfo)); /* jquant1.c */
+-EXTERN void jsel2quantize PP((decompress_info_ptr cinfo)); /* jquant2.c */
+-/* The user interface should call one of these to select input format: */
+-EXTERN void jselrjfif PP((decompress_info_ptr cinfo)); /* jrdjfif.c */
+-/* and one of these to select output image format: */
+-EXTERN void jselwgif PP((decompress_info_ptr cinfo)); /* jwrgif.c */
+-EXTERN void jselwppm PP((decompress_info_ptr cinfo)); /* jwrppm.c */
+-EXTERN void jselwrle PP((decompress_info_ptr cinfo)); /* jwrrle.c */
+-EXTERN void jselwtarga PP((decompress_info_ptr cinfo)); /* jwrtarga.c */
+-
+-/* method selection routines for system-dependent modules */
+-EXTERN void jselerror PP((external_methods_ptr emethods)); /* jerror.c */
+-EXTERN void jselmemmgr PP((external_methods_ptr emethods)); /* jmemmgr.c */
+-
++#ifdef EMBED
++  #define ERREXIT(emeth,msg) {tracef("Error:"); tracef(msg); newline(); EXIT}
++  #define ERREXIT1(emeth,msg,p1) {tracef("Error:"); tracef(msg _ p1); newline(); EXIT}
++  #define ERREXIT2(emeth,msg,p1,p2) {tracef("Error:"); tracef(msg _ p1 _ p2); newline(); EXIT}
++  #define ERREXIT3(emeth,msg,p1,p2,p3) {tracef("Error:"); tracef(msg _ p1 _ p2 _ p3); newline(); EXIT}
++  #define ERREXIT4(emeth,msg,p1,p2,p3,p4) {tracef("Error:"); tracef(msg _ p1 _ p2 _ p3 _ p4); newline(); EXIT}
++#else
++  #define ERREXIT(emeth,msg) {printf("Error:"); printf(msg); printf("\n"); exit(1);}
++  #define ERREXIT1(emeth,msg,p1) {printf("Error:"); printf(msg,p1); printf("\n"); exit(1);}
++  #define ERREXIT2(emeth,msg,p1,p2) {printf("Error:"); printf(msg,p1,p2); printf("\n"); exit(1);}
++  #define ERREXIT3(emeth,msg,p1,p2,p3) {printf("Error:"); printf(msg,p1,p2,p3); printf("\n"); exit(1);}
++  #define ERREXIT4(emeth,msg,p1,p2,p3,p4) {printf("Error:"); printf(msg,p1,p2,p3,p4); printf("\n"); exit(1);}
++#endif
+ 
+ /* We assume that right shift corresponds to signed division by 2 with
+  * rounding towards minus infinity.  This is correct for typical "arithmetic
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-5/jpeglib.h cvs/h/jpeglib
+--- jpeg-5/jpeglib.h	1994-08-25 15:20:36.000000000 +0100
++++ cvs/h/jpeglib	1996-11-05 09:45:08.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jpeglib.h
+  *
+@@ -738,7 +755,6 @@ typedef JMETHOD(boolean, jpeg_marker_par
+ #define jpeg_stdio_src		jStdSrc
+ #define jpeg_set_defaults	jSetDefaults
+ #define jpeg_set_colorspace	jSetColorspace
+-#define jpeg_default_colorspace	jDefColorspace
+ #define jpeg_set_quality	jSetQuality
+ #define jpeg_set_linear_quality	jSetLQuality
+ #define jpeg_add_quant_table	jAddQuantTable
+@@ -787,7 +803,6 @@ EXTERN void jpeg_set_defaults JPP((j_com
+ /* Compression parameter setup aids */
+ EXTERN void jpeg_set_colorspace JPP((j_compress_ptr cinfo,
+ 				     J_COLOR_SPACE colorspace));
+-EXTERN void jpeg_default_colorspace JPP((j_compress_ptr cinfo));
+ EXTERN void jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
+ 				  boolean force_baseline));
+ EXTERN void jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-3/jrdjfif.c cvs/c/jrdjfif
+--- jpeg-3/jrdjfif.c	1992-01-17 23:28:05.000000000 +0000
++++ cvs/c/jrdjfif	1996-11-05 09:45:03.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jrdjfif.c
+  *
+@@ -24,6 +41,8 @@
+  * These routines are invoked via the methods read_file_header,
+  * read_scan_header, read_jpeg_data, read_scan_trailer, and read_file_trailer.
+  */
++#undef FILE_
++#define FILE_ (20000)
+ 
+ #include "jinclude.h"
+ 
+@@ -85,37 +104,6 @@ typedef enum {			/* JPEG marker codes */
+ 
+ 
+ /*
+- * Reload the input buffer after it's been emptied, and return the next byte.
+- * This is exported for direct use by the entropy decoder.
+- * See the JGETC macro for calling conditions.
+- *
+- * For this header control module, read_jpeg_data is supplied by the
+- * user interface.  However, header formats that require random access
+- * to the input file would need to supply their own code.  This code is
+- * left here to indicate what is required.
+- */
+-
+-#if 0				/* not needed in this module */
+-
+-METHODDEF int
+-read_jpeg_data (decompress_info_ptr cinfo)
+-{
+-  cinfo->next_input_byte = cinfo->input_buffer + MIN_UNGET;
+-
+-  cinfo->bytes_in_buffer = (int) JFREAD(cinfo->input_file,
+-					cinfo->next_input_byte,
+-					JPEG_BUF_SIZE);
+-  
+-  if (cinfo->bytes_in_buffer <= 0)
+-    ERREXIT(cinfo->emethods, "Unexpected EOF in JPEG file");
+-
+-  return JGETC(cinfo);
+-}
+-
+-#endif
+-
+-
+-/*
+  * Routines to parse JPEG markers & save away the useful info.
+  */
+ 
+@@ -196,8 +184,10 @@ get_dht (decompress_info_ptr cinfo)
+     if (index < 0 || index >= NUM_HUFF_TBLS)
+       ERREXIT1(cinfo->emethods, "Bogus DHT index %d", index);
+ 
++#if 0
+     if (*htblptr == NULL)
+-      *htblptr = (HUFF_TBL *) (*cinfo->emethods->alloc_small) (SIZEOF(HUFF_TBL));
++      *htblptr = (HUFF_TBL *) malloc (SIZEOF(HUFF_TBL));
++#endif
+   
+     memcpy((void *) (*htblptr)->bits, (void *) bits,
+ 	   SIZEOF((*htblptr)->bits));
+@@ -262,9 +252,11 @@ get_dqt (decompress_info_ptr cinfo)
+     if (n >= NUM_QUANT_TBLS)
+       ERREXIT1(cinfo->emethods, "Bogus table number %d", n);
+       
++#if 0
+     if (cinfo->quant_tbl_ptrs[n] == NULL)
+       cinfo->quant_tbl_ptrs[n] = (QUANT_TBL_PTR)
+-	(*cinfo->emethods->alloc_small) (SIZEOF(QUANT_TBL));
++        malloc (SIZEOF(QUANT_TBL));
++#endif
+     quant_ptr = cinfo->quant_tbl_ptrs[n];
+ 
+     for (i = 0; i < DCTSIZE2; i++) {
+@@ -394,8 +386,14 @@ get_sof (decompress_info_ptr cinfo, int 
+   if (length != (cinfo->num_components * 3 + 8))
+     ERREXIT(cinfo->emethods, "Bogus SOF length");
+ 
+-  cinfo->comp_info = (jpeg_component_info *) (*cinfo->emethods->alloc_small)
++#if RISCOS
++  if (cinfo->num_components > 3)
++    ERREXIT(cinfo->emethods, "Too many colour components");
++  /* cinfo->comp_info set up already */
++#else
++  cinfo->comp_info = (jpeg_component_info *) malloc
+ 			(cinfo->num_components * SIZEOF(jpeg_component_info));
++#endif
+   
+   for (ci = 0; ci < cinfo->num_components; ci++) {
+     compptr = &cinfo->comp_info[ci];
+@@ -693,6 +691,7 @@ read_scan_header (decompress_info_ptr ci
+ }
+ 
+ 
++#if 0
+ /*
+  * Finish up after a compressed scan (series of read_jpeg_data calls);
+  * prepare for another read_scan_header call.
+@@ -703,8 +702,9 @@ read_scan_trailer (decompress_info_ptr c
+ {
+   /* no work needed */
+ }
++#endif
+ 
+-
++#if 0
+ /*
+  * Finish up at the end of the file.
+  */
+@@ -714,8 +714,10 @@ read_file_trailer (decompress_info_ptr c
+ {
+   /* no work needed */
+ }
++#endif
+ 
+ 
++#ifndef RISCOS
+ /*
+  * The method selection routine for standard JPEG header reading.
+  * Note that this must be called by the user interface before calling
+@@ -737,4 +739,5 @@ jselrjfif (decompress_info_ptr cinfo)
+   cinfo->methods->read_file_trailer = read_file_trailer;
+ }
+ 
++#endif
+ #endif /* JFIF_SUPPORTED */
+diff -U 3 -H -b -B -d -p -r -N -- jpeg-4/jrevdct.c cvs/c/jrevdct4
+--- jpeg-4/jrevdct.c	1992-11-11 02:27:59.000000000 +0000
++++ cvs/c/jrevdct4	1996-11-05 09:45:03.000000000 +0000
+@@ -1,3 +1,20 @@
++/* This source code in this file is licensed to You by Castle Technology
++ * Limited ("Castle") and its licensors on contractual terms and conditions
++ * ("Licence") which entitle you freely to modify and/or to distribute this
++ * source code subject to Your compliance with the terms of the Licence.
++ * 
++ * This source code has been made available to You without any warranties
++ * whatsoever. Consequently, Your use, modification and distribution of this
++ * source code is entirely at Your own risk and neither Castle, its licensors
++ * nor any other person who has contributed to this source code shall be
++ * liable to You for any loss or damage which You may suffer as a result of
++ * Your use, modification or distribution of this source code.
++ * 
++ * Full details of Your rights and obligations are set out in the Licence.
++ * You should have received a copy of the Licence with this source code file.
++ * If You have not received a copy, the text of the Licence is available
++ * online at www.castle-technology.co.uk/riscosbaselicence.htm
++ */
+ /*
+  * jrevdct.c
+  *
+@@ -17,6 +34,10 @@
+  * multiplication; this allows a very simple and accurate implementation in
+  * scaled fixed-point arithmetic, with a minimal number of shifts.
+  */
++#undef FILE_
++#define FILE_ (30000)
++/* This version has been updated to include gathering of statistics,
++for tuning other implementations. */
+ 
+ #include "jinclude.h"
+ 
+@@ -66,8 +87,10 @@
+  */
+ 
+ #ifdef EIGHT_BIT_SAMPLES
+-#define CONST_BITS  13
+-#define PASS1_BITS  2
++/* #define CONST_BITS  13 */
++/* #define PASS1_BITS  2 */
++#define CONST_BITS 8
++#define PASS1_BITS  8
+ #else
+ #define CONST_BITS  13
+ #define PASS1_BITS  1		/* lose a little precision to avoid overflow */
+@@ -122,7 +145,14 @@
+  * the fudge factor is correct for either sign of X.
+  */
+ 
+-#define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
++/* special case for if we're trying to reduce precision and speed things ups */
++#if PASS1_BITS == CONST_BITS
++  #define DESCALE1(x,n)  (x)
++  #define DESCALE(x,n) (x)
++#else
++  #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
++  #define DESCALE1 DESCALE
++#endif
+ 
+ /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+  * For 8-bit samples with the recommended scaling, all the variable
+@@ -135,26 +165,60 @@
+  * NB: for 12-bit samples, a full 32-bit multiplication will be needed.
+  */
+ 
+-#ifdef EIGHT_BIT_SAMPLES
+-#ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
+-#define MULTIPLY(var,const)  (((INT16) (var)) * ((INT16) (const)))
+-#endif
+-#ifdef SHORTxLCONST_32		/* known to work with Microsoft C 6.0 */
+-#define MULTIPLY(var,const)  (((INT16) (var)) * ((INT32) (const)))
+-#endif
++#ifndef RISCOS
++  #ifdef EIGHT_BIT_SAMPLES
++  #ifdef SHORTxSHORT_32           /* may work if 'int' is 32 bits */
++  #define MULTIPLY(var,const)  (((INT16) (var)) * ((INT16) (const)))
++  #endif
++  #ifdef SHORTxLCONST_32          /* known to work with Microsoft C 6.0 */
++  #define MULTIPLY(var,const)  (((INT16) (var)) * ((INT32) (const)))
++  #endif
++  #endif
+ #endif
+ 
+ #ifndef MULTIPLY		/* default definition */
+ #define MULTIPLY(var,const)  ((var) * (const))
+ #endif
+ 
++#ifdef STATS
++static int how_many(int a, int b, int c, int d, int e, int f, int g, int h)
++/* How many of these 8 numbers are nonzero? */
++{
++  int i = 0;
++  if (a) i++;
++  if (b) i++;
++  if (c) i++;
++  if (d) i++;
++  if (e) i++;
++  if (f) i++;
++  if (g) i++;
++  if (h) i++;
++  return i;
++}
++
++static int how_many_row(DCTELEM *p, int size)
++{
++  return how_many(   p[0]     , p[1*size], p[2*size], p[3*size],
++                     p[4*size], p[5*size], p[6*size], p[7*size]);
++}
++
++#endif
+ 
+ /*
+  * Perform the inverse DCT on one block of coefficients.
+  */
+ 
+ GLOBAL void
+-j_rev_dct (DCTBLOCK data)
++j_rev_dct (decompress_info_ptr cinfo, DCTBLOCK data, int count)
++/*
++ * NB in order to make the assembler equivalent more efficient, this routine
++ * now places its output at data-1, in row order. This is done as an
++ * entirely separate final pass.
++ *
++ * The output values are also unscaled, so you need to add 0x40000 and
++ * shift right by 19.
++ *
++ */
+ {
+   INT32 tmp0, tmp1, tmp2, tmp3;
+   INT32 tmp10, tmp11, tmp12, tmp13;
+@@ -163,6 +227,10 @@ j_rev_dct (DCTBLOCK data)
+   int rowctr;
+   SHIFT_TEMPS
+ 
++  for (; count > 0; count--, data = (DCTELEM*)data + DCTSIZE2) {
++
++  IFSTATS(cinfo->stats.n_jblocks++;)
++
+   /* Pass 1: process rows. */
+   /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
+   /* furthermore, we scale the results by 2**PASS1_BITS. */
+@@ -178,11 +246,17 @@ j_rev_dct (DCTBLOCK data)
+      * row DCT calculations can be simplified this way.
+      */
+ 
++      #ifdef STATS
++        cinfo->stats.n_lines_thismany_nonzero_coeffs_pass1[how_many_row(dataptr, 1)]++;
++      #endif
++
+     if ((dataptr[1] | dataptr[2] | dataptr[3] | dataptr[4] |
+ 	 dataptr[5] | dataptr[6] | dataptr[7]) == 0) {
+       /* AC terms all zero */
+-      DCTELEM dcval = (DCTELEM) (dataptr[0] << PASS1_BITS);
++        DCTELEM dcval;
+       
++        if (0 != (dcval = (DCTELEM) (dataptr[0] << PASS1_BITS)))
++        {
+       dataptr[0] = dcval;
+       dataptr[1] = dcval;
+       dataptr[2] = dcval;
+@@ -191,11 +265,33 @@ j_rev_dct (DCTBLOCK data)
+       dataptr[5] = dcval;
+       dataptr[6] = dcval;
+       dataptr[7] = dcval;
++        }
++
++        #ifdef STATS
++          cinfo->stats.n_pass1_ac_zero++;
++          if (dcval == 0) cinfo->stats.n_pass1_ac_dc_zero++;
++        #endif
+       
+       dataptr += DCTSIZE;	/* advance pointer to next row */
+       continue;
+     }
+ 
++      #ifdef STATS
++        cinfo->stats.n_pass1_ac_nonzero++;
++        if (0 == how_many(0,0,0,0,dataptr[0],dataptr[2],dataptr[4],dataptr[6])) cinfo->stats.n_pass1_even_zero++;
++        if (0 == how_many(0,0,0,0,dataptr[1],dataptr[3],dataptr[5],dataptr[7])) cinfo->stats.n_pass1_odd_zero++;
++        else cinfo->stats.n_pass1_odd_nonzero++;
++
++        /* Look for cases where all the high frequency coeffs are zero */
++        {
++          int i;
++          for (i = DCTSIZE-1; i >= 0; i--) if (dataptr[i] != 0) break;
++          cinfo->stats.higher_coeff_all_zero[i]++;
++        }
++      #endif
++
++      /* printf("n "); */
++
+     /* Even part: reverse the even part of the forward DCT. */
+     /* The rotator is sqrt(2)*c(-6). */
+ 
+@@ -248,14 +344,14 @@ j_rev_dct (DCTBLOCK data)
+ 
+     /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+ 
+-    dataptr[0] = (DCTELEM) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
+-    dataptr[7] = (DCTELEM) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
+-    dataptr[1] = (DCTELEM) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
+-    dataptr[6] = (DCTELEM) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
+-    dataptr[2] = (DCTELEM) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
+-    dataptr[5] = (DCTELEM) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
+-    dataptr[3] = (DCTELEM) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
+-    dataptr[4] = (DCTELEM) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
++      dataptr[0] = (DCTELEM) DESCALE1(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
++      dataptr[7] = (DCTELEM) DESCALE1(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
++      dataptr[1] = (DCTELEM) DESCALE1(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
++      dataptr[6] = (DCTELEM) DESCALE1(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
++      dataptr[2] = (DCTELEM) DESCALE1(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
++      dataptr[5] = (DCTELEM) DESCALE1(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
++      dataptr[3] = (DCTELEM) DESCALE1(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
++      dataptr[4] = (DCTELEM) DESCALE1(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
+ 
+     dataptr += DCTSIZE;		/* advance pointer to next row */
+   }
+@@ -274,7 +370,10 @@ j_rev_dct (DCTBLOCK data)
+      * may be commented out.
+      */
+ 
+-#ifndef NO_ZERO_COLUMN_TEST
++      IFSTATS(cinfo->stats.n_lines_thismany_nonzero_coeffs_pass2[how_many_row(dataptr, DCTSIZE)]++;)
++
++  /* #ifndef NO_ZERO_COLUMN_TEST */
++  #if 0
+     if ((dataptr[DCTSIZE*1] | dataptr[DCTSIZE*2] | dataptr[DCTSIZE*3] |
+ 	 dataptr[DCTSIZE*4] | dataptr[DCTSIZE*5] | dataptr[DCTSIZE*6] |
+ 	 dataptr[DCTSIZE*7]) == 0) {
+@@ -290,10 +389,12 @@ j_rev_dct (DCTBLOCK data)
+       dataptr[DCTSIZE*6] = dcval;
+       dataptr[DCTSIZE*7] = dcval;
+       
++        /* printf("z2 "); */
++        
+       dataptr++;		/* advance pointer to next column */
+       continue;
+     }
+-#endif
++  #endif
+ 
+     /* Even part: reverse the even part of the forward DCT. */
+     /* The rotator is sqrt(2)*c(-6). */
+@@ -366,4 +467,19 @@ j_rev_dct (DCTBLOCK data)
+     
+     dataptr++;			/* advance pointer to next column */
+   }
++
++    /* Final pass to place output in an order compatible with the
++    assembler equivalent. */
++    dataptr = data;
++    {
++      int *inptr = dataptr;
++      int *outptr = inptr - 64;
++      int col;
++      int row;
++
++      for (row = 0; row < 8; row++)
++        for (col = 0; col < 8; col++)
++          outptr[row + 8 * col] = inptr[row * 8 + col];
++    }
++  }
+ }
diff --git a/Doc/JPEG/README_v3 b/Doc/JPEG/README_v3
new file mode 100644
index 0000000..3dc1140
--- /dev/null
+++ b/Doc/JPEG/README_v3
@@ -0,0 +1,360 @@
+The Independent JPEG Group's JPEG software
+==========================================
+
+README for release 3 of  17-Mar-92
+==================================
+
+This distribution contains the third official release of the Independent JPEG
+Group's free JPEG software.  You are welcome to redistribute this software and
+to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
+
+For installation instructions, see file SETUP; for usage instructions, see
+file USAGE (or the cjpeg.1 and djpeg.1 manual pages).
+
+This software is still undergoing revision.  Updated versions may be obtained
+by FTP or UUCP to UUNET and other archive sites; see ARCHIVE LOCATIONS below
+for details.
+
+If you intend to become a serious user of this software, please contact
+jpeg-info@uunet.uu.net to be added to our electronic mailing list.  Then
+you'll be notified of updates and have a chance to participate in discussions,
+etc.
+
+This software is the work of Tom Lane, Philip Gladstone, Luis Ortiz,
+Lee Crocker, Ge' Weijers, and other members of the Independent JPEG Group.
+
+
+DISCLAIMER
+==========
+
+THIS SOFTWARE IS NOT COMPLETE NOR FULLY DEBUGGED.  It is not guaranteed to be
+useful for anything, nor to be compatible with subsequent releases, nor to be
+an accurate implementation of the JPEG standard.  (See LEGAL ISSUES for even
+more disclaimers.)
+
+Please report any problems with this software to jpeg-info@uunet.uu.net.
+
+
+WHAT'S HERE
+===========
+
+This distribution contains C software to implement JPEG image compression and
+decompression.  JPEG (pronounced "jay-peg") is a standardized compression
+method for full-color and gray-scale images.  JPEG is intended for
+"real-world" scenes; cartoons and other non-realistic images are not its
+strong suit.  JPEG is lossy, meaning that the output image is not necessarily
+identical to the input image.  Hence you should not use JPEG if you have to
+have identical output bits.  However, on typical images of real-world scenes,
+very good compression levels can be obtained with no visible change, and
+amazingly high compression levels can be obtained if you can tolerate a
+low-quality image.  For more details, see the references, or just experiment
+with various compression settings.
+
+The software implements JPEG baseline and extended-sequential compression
+processes.  Provision is made for supporting all variants of these processes,
+although some uncommon parameter settings aren't implemented yet.  For legal
+reasons, we are not distributing code for the arithmetic-coding process; see
+LEGAL ISSUES.  At present we have made no provision for supporting the
+progressive, hierarchical, or lossless processes defined in the standard.
+
+The present software is not far beyond the prototype stage.  It does not
+support all possible variants of the JPEG standard, and some functions have
+rather slow and/or crude implementations.  However, it is useful already.
+
+The emphasis in designing this software has been on achieving portability and
+flexibility, while also making it fast enough to be useful.  We have not yet
+undertaken serious performance measurement or tuning; we intend to do so in
+the future.
+
+
+This software can be used on several levels:
+
+* As canned software for JPEG compression and decompression.  Just edit the
+  Makefile and configuration files as needed (see file SETUP), compile and go.
+  Members of the Independent JPEG Group will improve the out-of-the-box
+  functionality and speed as time goes on.
+
+* As the basis for other JPEG programs.  For example, you could incorporate
+  the decompressor into a general image viewing package by replacing the
+  output module with write-to-screen functions.  For an implementation on
+  specific hardware, you might want to replace some of the inner loops with
+  assembly code.  For a non-command-line-driven system, you might want a
+  different user interface.  (Members of the group will be producing Macintosh
+  and Amiga versions with more appropriate user interfaces, for example.)
+
+* As a toolkit for experimentation with JPEG and JPEG-like algorithms.  Most
+  of the individual decisions you might want to mess with are packaged up into
+  separate modules.  For example, the details of color-space conversion and
+  subsampling techniques are each localized in one compressor and one
+  decompressor module.  You'd probably also want to extend the user interface
+  to give you more detailed control over the JPEG compression parameters.
+
+In particular, we welcome the use of this software as a component of commercial
+products; no royalty is required.
+
+
+ARCHIVE LOCATIONS
+=================
+
+The "official" archive site for this software is ftp.uu.net (Internet
+address 137.39.1.9 or 192.48.96.9).  The most recent released version can
+always be found there in directory graphics/jpeg.  This particular version
+will be archived as jpegsrc.v3.tar.Z.  If you are on the Internet, you can
+retrieve files from UUNET by anonymous FTP.  If you don't have FTP access,
+UUNET's archives are also available via UUCP; contact postmaster@uunet.uu.net
+for information on retrieving files that way.
+
+Various other Internet sites maintain copies of the UUNET file, which may or
+may not be up-to-date.  In Europe, try nic.funet.fi (128.214.6.100; look in
+directory pub/graphics/programs/jpeg).
+
+You can also obtain this software from CompuServe, in the GRAPHSUPPORT forum
+(GO PICS), library 10; this version will be file jpsrc3.zip.
+
+If you are not reasonably handy at configuring and installing portable C
+programs, you may have some difficulty installing this package.  You may
+prefer to obtain a pre-built executable version.  A collection of pre-built
+executables for various machines is currently available for anonymous FTP at
+procyon.cis.ksu.edu (129.130.10.80 --- this number is due to change soon);
+look under /pub/JPEG.  The administrators of this system ask that FTP traffic
+be limited to non-prime hours.  For more information on this archive, please
+contact Steve Davis (strat@cis.ksu.edu).  This collection is not maintained by
+the Independent JPEG Group, and programs in it may not be the latest version.
+
+
+SUPPORTING SOFTWARE
+===================
+
+You will probably want Jef Poskanzer's PBMPLUS image software, which provides
+many useful operations on PPM-format image files.  In particular, it can
+convert PPM images to and from a wide range of other formats.  You can FTP
+this free software from export.lcs.mit.edu (contrib/pbmplus*.tar.Z) or
+ftp.ee.lbl.gov (pbmplus*.tar.Z).  Unfortunately PBMPLUS is not nearly as
+portable as the JPEG software is; you are likely to have difficulty making it
+work on any non-Unix machine.
+
+If you are using X Windows you might want to use the xv or xloadimage viewers
+to save yourself the trouble of converting PPM to some other format.  Both of
+these can be found in the contrib directory at export.lcs.mit.edu.  Actually,
+xv version 2.00 and up incorporates our software and thus can read and write
+JPEG files directly.  (NOTE: since xv internally reduces all images to 8
+bits/pixel, a JPEG file written by xv will not be very high quality; you may
+also prefer xloadimage for viewing if you have a 24-bit display.  Caveat user.)
+
+For DOS machines, Lee Crocker's free Piclab program is a useful companion to
+the JPEG software.  The latest version, currently 1.91, is available by FTP
+from SIMTEL20 and its various mirror sites, file <msdos.graphics>piclb191.zip.
+CompuServe also has it, in the same library as the JPEG software.
+
+
+SOFTWARE THAT'S NO HELP AT ALL
+==============================
+
+Handmade Software's shareware PC program GIF2JPG produces files that are
+totally incompatible with our programs.  They use a proprietary format that is
+an amalgam of GIF and JPEG representations.  However, you can force GIF2JPG
+to produce compatible files with its -j switch, and their decompression
+program JPG2GIF can read our files (at least ones produced with our default
+option settings).
+
+Unfortunately, many commercial JPEG implementations are also incompatible as
+of this writing, especially programs released before summer 1991.  The root of
+the problem is that the ISO JPEG committee failed to specify a concrete file
+format.  Some vendors "filled in the blanks" on their own, creating
+proprietary formats that no one else could read.  (For example, none of the
+early commercial JPEG implementations for the Macintosh were able to exchange
+compressed files.)
+
+The file format we have adopted is called JFIF (see REFERENCES).  This format
+has been agreed to by a number of major commercial JPEG vendors, and we expect
+that it will become the de facto standard.  JFIF is a minimal representation;
+work is also going forward to incorporate JPEG compression into the TIFF
+standard, for use in "high end" applications that need to record a lot of
+additional data about an image.  We intend to support JPEG-in-TIFF in the
+future.  We hope that these two formats will be sufficient and that other,
+incompatible JPEG file formats will not proliferate.
+
+Indeed, part of the reason for developing and releasing this free software is
+to help force rapid convergence to de facto standards for JPEG file formats.
+SUPPORT STANDARD, NON-PROPRIETARY FORMATS: demand JFIF or JPEG-in-TIFF!
+
+
+USING JPEG AS A SUBROUTINE IN A LARGER PROGRAM
+==============================================
+
+You can readily incorporate the JPEG compression and decompression routines in
+a larger program.  The file example.c provides a skeleton of the interface
+routines you'll need for this purpose.  Essentially, you replace jcmain.c (for
+compression) and/or jdmain.c (for decompression) with your own code.  Note
+that the fewer JPEG options you allow the user to twiddle, the less code you
+need; all the default options are set up automatically.  (Alternately, if you
+know a lot about JPEG or have a special application, you may want to twiddle
+the default options even more extensively than jcmain/jdmain do.)
+
+Most likely, you will want the uncompressed image to come from memory (for
+compression) or go to memory or the screen (for decompression).  For this
+purpose you must provide image reading or writing routines that match the
+interface used by the image file I/O modules (jrdXXX or jwrXXX); again,
+example.c shows a skeleton of what is required.
+
+By default, any error detected inside the JPEG routines will cause a message
+to be printed on stderr, followed by exit().  You can override this behavior
+by supplying your own message-printing and/or error-exit routines; again,
+example.c shows how.
+
+Mechanics: we recommend you create libjpeg.a as shown in the Makefile, then
+link that with your surrounding program.  (If your linker is at all
+reasonable, only the code you actually need will get loaded.)  Include the
+files jconfig.h and jpegdata.h in C files that need to call the JPEG routines.
+
+CAUTION: some people have tried to compile JPEG and their surrounding code
+with different compilers, e.g., cc for JPEG and c++ or gcc for the rest.  This
+is a Real Bad Move and you will deserve what happens to you if you try it.
+(Hint: the parameter structures can get laid out differently with no warning.)
+
+Read our "architecture" file for more info.  If it seems to you that the
+software structure doesn't accommodate what you want to do, please contact
+the authors.
+
+Beginning with version 3, we will endeavor to hold the interface described by
+example.c constant, so that you can plug in updated versions of the JPEG code
+just by recompiling.  However, we can't guarantee this, especially if you
+choose to twiddle any JPEG options not listed in example.c.  Check the
+CHANGELOG when installing any new version, and compare example.c against the
+prior version.  Recompile your calling software (don't just relink), as we may
+add or subtract fields in the parameter structures.
+
+
+REFERENCES
+==========
+
+The best and most readily available introduction to the JPEG compression
+algorithm is Wallace's article in the April '91 CACM:
+	Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+(Adjacent articles in that issue discuss MPEG motion picture compression,
+applications of JPEG, and related topics.)  We highly recommend reading that
+article before trying to understand the innards of any JPEG software.
+If you don't have the CACM issue handy, a PostScript file containing a revised
+version of the article is available at ftp.uu.net, graphics/jpeg/wallace.ps.Z.
+The file (actually a preprint for an article to appear in IEEE Trans. Consumer
+Electronics) omits the sample images that appeared in CACM, but it includes
+corrections and some added material.  Note: the Wallace article is copyright
+ACM and IEEE, and it may not be used for commercial purposes.
+
+For more detail about the JPEG standard you pretty much have to go to the
+draft standard (which is not nearly as intelligible as Wallace's article).
+The standard is not now available electronically; you must order a paper copy
+through ISO.  In the US, copies may be ordered from ANSI Sales at (212)
+642-4900.  The standard is divided into two parts: Part 1 is the actual
+specification, and Part 2 covers compliance testing methods.  The current
+"committee draft" version of Part 1 is titled "Digital Compression and Coding
+of Continuous-tone Still Images, Part 1: Requirements and guidelines" and has
+document number ISO/IEC CD 10918-1.  (The alternate number SC2 N2215 should
+also be mentioned when ordering.)  This draft is expected to be superseded by
+the Draft International Standard version around the end of November 1991.
+Ordering info will be the same as above, but replace "CD" with "DIS" in the
+document number (alternate number not yet known).  The committee draft of
+Part 2 is expected to be available around the end of December 1991.  It will
+be titled "Digital Compression and Coding of Continuous-tone Still Images,
+Part 2: Compliance testing" and will have document number ISO/IEC CD 10918-2
+(alternate number not yet known).
+
+The JPEG standard does not specify all details of an interchangeable file
+format.  For the omitted details we follow the "JFIF" conventions, revision
+1.01.  A copy of the JFIF spec is available from:
+	Literature Department
+	C-Cube Microsystems, Inc.
+	399A West Trimble Road
+	San Jose, CA  95131
+	(408) 944-6300
+The same source can supply copies of the draft JPEG-in-TIFF documents
+(Appendixes O and P to the TIFF spec).  PostScript versions of these
+documents can also be obtained by e-mail from the C-Cube mail server,
+netlib@c3.pla.ca.us.  Send the message "send jfif_ps from jpeg" to obtain the
+JFIF document; "send app_o_ps from jpeg" and "send app_p_ps from jpeg" will
+produce the TIFF documents.  Send the message "help" if you have trouble.
+
+If you want to understand this implementation, start by reading the
+"architecture" documentation file.  Please read "codingrules" if you want to
+contribute any code.
+
+
+LEGAL ISSUES
+============
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose.  This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991, 1992, Thomas G. Lane.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+Permission is NOT granted for the use of any author's name or author's company
+name in advertising or publicity relating to this software or products derived
+from it.  This software may be referred to only as "the Independent JPEG
+Group's software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
+sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
+ansi2knr.c is NOT covered by the above copyright and conditions, but instead
+by the usual distribution terms of the Free Software Foundation; principally,
+that you must include source code if you redistribute it.  (See the file
+ansi2knr.c for full details.)  However, since ansi2knr.c is not needed as part
+of any product generated from the JPEG code, this does not limit you more than
+the foregoing paragraphs do.
+
+
+It appears that the arithmetic coding option of the JPEG spec is covered by
+patents owned by IBM and AT&T, as well as a pending Japanese patent of
+Mitsubishi.  Hence arithmetic coding cannot legally be used without obtaining
+one or more licenses.  For this reason, support for arithmetic coding has been
+removed from the free JPEG software.  (Since arithmetic coding provides only a
+marginal gain over the unpatented Huffman mode, it is unlikely that very many
+people will choose to use it.  If you do obtain the necessary licenses,
+contact jpeg-info@uunet.uu.net for a copy of our arithmetic coding modules.)
+So far as we are aware, there are no patent restrictions on the remaining
+code.
+
+
+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."
+
+
+TO DO
+=====
+
+Many of the modules need fleshing out to provide more complete
+implementations, or to provide faster paths for common cases.
+Improving the speed will be the next big work item for the JPEG group.
+
+We'd appreciate it if people would compile and check out the code on as wide a
+variety of systems as possible, and report any portability problems
+encountered (with solutions, if possible).  Checks of file compatibility with
+other JPEG implementations would also be of interest.  Finally, we would
+appreciate code profiles showing where the most time is spent, especially on
+unusual systems.
+
+Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net.
diff --git a/Doc/JPEG/README_v4 b/Doc/JPEG/README_v4
new file mode 100644
index 0000000..9223de2
--- /dev/null
+++ b/Doc/JPEG/README_v4
@@ -0,0 +1,401 @@
+The Independent JPEG Group's JPEG software
+==========================================
+
+README for release 4 of 10-Dec-92
+=================================
+
+This distribution contains the fourth public release of the Independent JPEG
+Group's free JPEG software.  You are welcome to redistribute this software and
+to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
+
+For installation instructions, see file SETUP.
+
+For usage instructions, see file USAGE (or the cjpeg.1 and djpeg.1 manual
+pages; but USAGE contains a "hints" section not found in the manual pages).
+Useful information can also be found in the JPEG FAQ (Frequently Asked
+Questions) article; see ARCHIVE LOCATIONS below to obtain the FAQ article.
+
+This software is still undergoing revision.  Updated versions may be obtained
+by FTP or UUCP to UUNET and other archive sites; see ARCHIVE LOCATIONS below
+for details.
+
+Serious users of this software (particularly those incorporating it into
+larger programs) should contact jpeg-info@uunet.uu.net to be added to our
+electronic mailing list.  Mailing list members are notified of updates and
+have a chance to participate in technical discussions, etc.
+
+This software is the work of Tom Lane, Philip Gladstone, Luis Ortiz,
+Lee Crocker, Ge' Weijers, and other members of the Independent JPEG Group.
+
+
+DISCLAIMER
+==========
+
+THIS SOFTWARE IS NOT COMPLETE NOR FULLY DEBUGGED.  It is not guaranteed to be
+useful for anything, nor to be compatible with subsequent releases, nor to be
+an accurate implementation of the JPEG standard.  (See LEGAL ISSUES for even
+more disclaimers.)
+
+Despite that, we believe that this software is pretty good, and if you find
+any problems with it, we'd like to know about them.  Please report problems
+by e-mail to jpeg-info@uunet.uu.net.
+
+
+WHAT'S HERE
+===========
+
+This distribution contains C software to implement JPEG image compression and
+decompression.  JPEG (pronounced "jay-peg") is a standardized compression
+method for full-color and gray-scale images.  JPEG is intended for compressing
+"real-world" scenes; cartoons and other non-realistic images are not its
+strong suit.  JPEG is lossy, meaning that the output image is not necessarily
+identical to the input image.  Hence you must not use JPEG if you have to have
+identical output bits.  However, on typical images of real-world scenes, very
+good compression levels can be obtained with no visible change, and amazingly
+high compression levels are possible if you can tolerate a low-quality image.
+For more details, see the references, or just experiment with various
+compression settings.
+
+The software implements JPEG baseline and extended-sequential compression
+processes.  Provision is made for supporting all variants of these processes,
+although some uncommon parameter settings aren't implemented yet.  For legal
+reasons, we are not distributing code for the arithmetic-coding process; see
+LEGAL ISSUES.  At present we have made no provision for supporting the
+progressive, hierarchical, or lossless processes defined in the standard.
+
+In order to support file conversion and viewing software, we have included
+considerable functionality beyond the bare JPEG coding/decoding capability;
+for example, the color quantization modules are not strictly part of JPEG
+decoding, but they are essential for output to colormapped file formats or
+colormapped displays.  These extra functions can be compiled out if not
+required for a particular application.
+
+The emphasis in designing this software has been on achieving portability and
+flexibility, while also making it fast enough to be useful.  In particular,
+the software is not intended to be read as a tutorial on JPEG.  (See the
+REFERENCES section for introductory material.)  While we hope that the entire
+package will someday be industrial-strength code, much remains to be done in
+performance tuning and in improving the capabilities of individual modules.
+
+
+This software can be used on several levels:
+
+* As canned software for JPEG compression and decompression.  Just edit the
+  Makefile and configuration files as needed (see file SETUP), compile and go.
+  Members of the Independent JPEG Group will improve the out-of-the-box
+  functionality and speed as time goes on.
+
+* As the basis for other JPEG programs.  For example, you could incorporate
+  the decompressor into a general image viewing package by replacing the
+  output module with write-to-screen functions.  For an implementation on
+  specific hardware, you might want to replace some of the inner loops with
+  assembly code.  For a non-command-line-driven system, you might want a
+  different user interface.  (Members of the group will be producing Macintosh
+  and Amiga versions with more appropriate user interfaces, for example.)
+
+* As a toolkit for experimentation with JPEG and JPEG-like algorithms.  Most
+  of the individual decisions you might want to mess with are packaged up into
+  separate modules.  For example, the details of color-space conversion and
+  subsampling techniques are each localized in one compressor and one
+  decompressor module.  You'd probably also want to extend the user interface
+  to give you more detailed control over the JPEG compression parameters.
+
+In particular, we welcome the use of this software as a component of commercial
+products; no royalty is required.
+
+
+ARCHIVE LOCATIONS
+=================
+
+The "official" archive site for this software is ftp.uu.net (Internet
+address 137.39.1.9 or 192.48.96.9).  The most recent released version can
+always be found there in directory graphics/jpeg.  This particular version
+will be archived as jpegsrc.v4.tar.Z.  If you are on the Internet, you can
+retrieve files from UUNET by anonymous FTP.  If you don't have FTP access,
+UUNET's archives are also available via UUCP; contact postmaster@uunet.uu.net
+for information on retrieving files that way.
+
+Numerous Internet sites maintain copies of the UUNET files; in particular,
+you can probably find a copy at any site that archives comp.sources.misc
+submissions.  However, only ftp.uu.net is guaranteed to have the latest
+official version.
+
+You can also obtain this software from CompuServe, in the GRAPHSUPPORT forum
+(GO PICS), library 15; this version will be file jpsrc4.zip.  Again,
+CompuServe is not guaranteed to have the very latest version.
+
+The JPEG FAQ (Frequently Asked Questions) article is a useful source of
+general information about JPEG.  It is updated constantly and therefore
+is not included in this distribution.  The FAQ is posted every two weeks
+to Usenet newsgroups comp.graphics, news.answers, and other groups.  You
+can always obtain the latest version from the news.answers archive at
+rtfm.mit.edu (18.172.1.27).  By FTP, fetch /pub/usenet/news.answers/jpeg-faq.
+If you don't have FTP, send e-mail to mail-server@rtfm.mit.edu with body
+"send usenet/news.answers/jpeg-faq".
+
+
+SUPPORTING SOFTWARE
+===================
+
+You will probably want Jef Poskanzer's PBMPLUS image software, which provides
+many useful operations on PPM-format image files.  In particular, it can
+convert PPM images to and from a wide range of other formats.  You can FTP
+this free software from export.lcs.mit.edu (contrib/pbmplus*.tar.Z) or
+ftp.ee.lbl.gov (pbmplus*.tar.Z).  Unfortunately PBMPLUS is not nearly as
+portable as the JPEG software is; you are likely to have difficulty making it
+work on any non-Unix machine.
+
+If you are using X Windows you might want to use the xv or xloadimage viewers
+to save yourself the trouble of converting PPM to some other format.  Both of
+these can be found in the contrib directory at export.lcs.mit.edu.  Actually,
+xv version 2.00 and up incorporates our software and thus can read and write
+JPEG files directly.  (NOTE: since xv internally reduces all images to 8
+bits/pixel, a JPEG file written by xv will not be very high quality; and xv
+cannot fully exploit a 24-bit display.  These problems are expected to go away
+in the next xv release, planned for early 1993.  In the meantime, use
+xloadimage for 24-bit displays.)
+
+For DOS machines, Lee Crocker's free Piclab program is a useful companion to
+the JPEG software.  The latest version, currently 1.91, is available by FTP
+from SIMTEL20 and its various mirror sites, file <msdos.graphics>piclb191.zip.
+CompuServe also has it, in the same library as the JPEG software.
+
+
+SOFTWARE THAT'S NO HELP AT ALL
+==============================
+
+Handmade Software's shareware PC program GIF2JPG produces files that are
+totally incompatible with our programs.  They use a proprietary format that is
+an amalgam of GIF and JPEG representations.  However, you can force GIF2JPG
+to produce compatible files with its -j switch, and their decompression
+program JPG2GIF can read our files (at least ones produced with our default
+option settings).
+
+Some commercial JPEG implementations are also incompatible as of this writing,
+especially programs released before summer 1991.  The root of the problem is
+that the ISO JPEG committee failed to specify a concrete file format.  Some
+vendors "filled in the blanks" on their own, creating proprietary formats that
+no one else could read.  (For example, none of the early commercial JPEG
+implementations for the Macintosh were able to exchange compressed files.)
+
+The file format we have adopted is called JFIF (see REFERENCES).  This format
+has been agreed to by a number of major commercial JPEG vendors, and we expect
+that it will become the de facto standard.  JFIF is a minimal representation;
+work is also going forward to incorporate JPEG compression into the TIFF 6.0
+standard, for use in "high end" applications that need to record a lot of
+additional data about an image.  We intend to support TIFF 6.0 in the future.
+We hope that these two formats will be sufficient and that other, incompatible
+JPEG file formats will not proliferate.
+
+Indeed, part of the reason for developing and releasing this free software is
+to help force rapid convergence to de facto standards for JPEG file formats.
+SUPPORT STANDARD, NON-PROPRIETARY FORMATS: demand JFIF or TIFF 6.0!
+
+
+USING JPEG AS A SUBROUTINE IN A LARGER PROGRAM
+==============================================
+
+You can readily incorporate the JPEG compression and decompression routines in
+a larger program.  The file example.c provides a skeleton of the interface
+routines you'll need for this purpose.  Essentially, you replace jcmain.c (for
+compression) and/or jdmain.c (for decompression) with your own code.  Note
+that the fewer JPEG options you allow the user to twiddle, the less code you
+need; all the default options are set up automatically.  (Alternately, if you
+know a lot about JPEG or have a special application, you may want to twiddle
+the default options even more extensively than jcmain/jdmain do.)
+
+Most likely, you will want the uncompressed image to come from memory (for
+compression) or go to memory or the screen (for decompression).  For this
+purpose you must provide image reading or writing routines that match the
+interface used by the image file I/O modules (jrdXXX or jwrXXX); again,
+example.c shows a skeleton of what is required.  In this situation, you
+won't need any of the non-JPEG image file I/O modules used by cjpeg and djpeg.
+
+By default, any error detected inside the JPEG routines will cause a message
+to be printed on stderr, followed by exit().  You can override this behavior
+by supplying your own message-printing and/or error-exit routines; again,
+example.c shows how.
+
+We recommend you create libjpeg.a as shown in the Makefile, then link that
+with your surrounding program.  (If your linker is at all reasonable, only the
+code you actually need will get loaded.)  Include the files jconfig.h and
+jpegdata.h in C files that need to call the JPEG routines.
+
+CAUTION: some people have tried to compile JPEG and their surrounding code
+with different compilers, e.g., cc for JPEG and c++ or gcc for the rest.  This
+is a Real Bad Move and you will deserve what happens to you if you try it.
+(Hint: the parameter structures can get laid out differently with no warning.)
+
+Read our "architecture" file for more info.  If it seems to you that the
+software structure doesn't accommodate what you want to do, please contact
+the authors.
+
+Beginning with version 3, we will endeavor to hold the interface described by
+example.c constant, so that you can plug in updated versions of the JPEG code
+just by recompiling.  However, we can't guarantee this, especially if you
+choose to twiddle any JPEG options not listed in example.c.  Check the
+CHANGELOG when installing any new version, and compare example.c against the
+prior version.  Recompile your calling software (don't just relink), as we may
+add or subtract fields in the parameter structures.
+
+
+REFERENCES
+==========
+
+We highly recommend reading one or more of these references before trying to
+understand the innards of any JPEG software.
+
+The best short technical introduction to the JPEG compression algorithm is
+	Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+(Adjacent articles in that issue discuss MPEG motion picture compression,
+applications of JPEG, and related topics.)  If you don't have the CACM issue
+handy, a PostScript file containing a revised version of the article is
+available at ftp.uu.net, graphics/jpeg/wallace.ps.Z.  The file (actually a
+preprint for an article to appear in IEEE Trans. Consumer Electronics) omits
+the sample images that appeared in CACM, but it includes corrections and some
+added material.  Note: the Wallace article is copyright ACM and IEEE, and it
+may not be used for commercial purposes.
+
+A somewhat less technical, more leisurely introduction to JPEG can be found in
+"The Data Compression Book" by Mark Nelson, published by M&T Books (Redwood
+City, CA), 1991, ISBN 1-55851-216-0.  This book provides good explanations and
+example C code for a multitude of compression methods including JPEG.  It is
+an excellent source if you are comfortable reading C code but don't know much
+about data compression in general.  The book's JPEG sample code is far from
+industrial-strength, but when you are ready to look at a full implementation,
+you've got one here...
+
+A new textbook about JPEG is "JPEG Still Image Data Compression Standard" by
+William B. Pennebaker and Joan L. Mitchell, published by Van Nostrand
+Reinhold, 1993, ISBN 0-442-01272-1.  Price US$59.95.  This book includes the
+complete text of the ISO JPEG standards (DIS 10918-1 and draft DIS 10918-2).
+This is by far the most complete exposition of JPEG in existence, and I highly
+recommend it.  If you read the entire book, you will probably know more about
+JPEG than I do.
+
+The JPEG standard itself is not available electronically; you must order a
+paper copy through ISO.  (Unless you are concerned about having a certified
+official copy, I recommend buying the Pennebaker and Mitchell book instead;
+it's much cheaper and includes a great deal of useful explanatory material.)
+In the US, copies of the standard may be ordered from ANSI Sales at (212)
+642-4900.  It's not cheap: as of 1992, Part 1 is $95 and Part 2 is $47, plus
+7% shipping/handling.  The standard is divided into two parts, Part 1 being
+the actual specification, while Part 2 covers compliance testing methods.
+As of early 1992, Part 1 has Draft International Standard status.  It is
+titled "Digital Compression and Coding of Continuous-tone Still Images, Part
+1: Requirements and guidelines" and has document number ISO/IEC DIS 10918-1.
+Part 2 is still at Committee Draft status.  It is titled "Digital Compression
+and Coding of Continuous-tone Still Images, Part 2: Compliance testing" and
+has document number ISO/IEC CD 10918-2.  (NOTE: I'm told that the final
+version of Part 2 will differ considerably from the CD draft.)
+
+The JPEG standard does not specify all details of an interchangeable file
+format.  For the omitted details we follow the "JFIF" conventions, revision
+1.02.  A copy of the JFIF spec is available from:
+	Literature Department
+	C-Cube Microsystems, Inc.
+	399A West Trimble Road
+	San Jose, CA  95131
+	(408) 944-6300
+A PostScript version of this document is available at ftp.uu.net, file
+graphics/jpeg/jfif.ps.Z.  It can also be obtained by e-mail from the C-Cube
+mail server, netlib@c3.pla.ca.us.  Send the message "send jfif_ps from jpeg"
+to the server to obtain the JFIF document; send the message "help" if you have
+trouble.
+
+The TIFF 6.0 file format specification can be obtained by FTP from sgi.com
+(192.48.153.1), file graphics/tiff/TIFF6.ps.Z; or you can order a printed copy
+from Aldus Corp. at (206) 628-6593.  It should be noted that the TIFF 6.0 spec
+of 3-June-92 has a number of serious problems in its JPEG features.  A
+clarification note will probably be needed to ensure that TIFF JPEG files are
+compatible across different implementations.  The IJG does not intend to
+support TIFF 6.0 until these problems are resolved.
+
+If you want to understand this implementation, start by reading the
+"architecture" documentation file.  Please read "codingrules" if you want to
+contribute any code.
+
+
+LEGAL ISSUES
+============
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose.  This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991, 1992, Thomas G. Lane.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it.  This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
+sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
+ansi2knr.c is NOT covered by the above copyright and conditions, but instead
+by the usual distribution terms of the Free Software Foundation; principally,
+that you must include source code if you redistribute it.  (See the file
+ansi2knr.c for full details.)  However, since ansi2knr.c is not needed as part
+of any program generated from the JPEG code, this does not limit you more than
+the foregoing paragraphs do.
+
+
+It appears that the arithmetic coding option of the JPEG spec is covered by
+patents owned by IBM and AT&T, as well as a pending Japanese patent of
+Mitsubishi.  Hence arithmetic coding cannot legally be used without obtaining
+one or more licenses.  For this reason, support for arithmetic coding has been
+removed from the free JPEG software.  (Since arithmetic coding provides only a
+marginal gain over the unpatented Huffman mode, it is unlikely that very many
+implementors will support it.  If you do obtain the necessary licenses,
+contact jpeg-info@uunet.uu.net for a copy of our arithmetic coding modules.)
+So far as we are aware, there are no patent restrictions on the remaining
+code.
+
+
+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."
+
+
+TO DO
+=====
+
+The next major release will probably be a significant rewrite to allow use of
+this code in conjunction with Sam Leffler's free TIFF library (assuming the
+bugs in the TIFF 6.0 specification get resolved).
+
+Many of the modules need fleshing out to provide more complete
+implementations, or to provide faster paths for common cases.
+Speeding things up is still high on our priority list.
+
+We'd appreciate it if people would compile and check out the code on as wide a
+variety of systems as possible, and report any portability problems
+encountered (with solutions, if possible).  Checks of file compatibility with
+other JPEG implementations would also be of interest.  Finally, we would
+appreciate code profiles showing where the most time is spent, especially on
+unusual systems.
+
+Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net.
diff --git a/Doc/JPEG/README_v5 b/Doc/JPEG/README_v5
new file mode 100644
index 0000000..c882ffb
--- /dev/null
+++ b/Doc/JPEG/README_v5
@@ -0,0 +1,349 @@
+The Independent JPEG Group's JPEG software
+==========================================
+
+README for release 5 of 24-Sep-94
+=================================
+
+This distribution contains the fifth public release of the Independent JPEG
+Group's free JPEG software.  You are welcome to redistribute this software and
+to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
+
+Serious users of this software (particularly those incorporating it into
+larger programs) should contact jpeg-info@uunet.uu.net to be added to our
+electronic mailing list.  Mailing list members are notified of updates and
+have a chance to participate in technical discussions, etc.
+
+This software is the work of Tom Lane, Philip Gladstone, Luis Ortiz, Jim
+Boucher, Lee Crocker, George Phillips, Davide Rossi, Ge' Weijers, and other
+members of the Independent JPEG Group.
+
+IJG is not associated with the official ISO JPEG standards committee.
+
+
+DOCUMENTATION ROADMAP
+=====================
+
+This file contains the following sections:
+
+OVERVIEW            General description of JPEG and the IJG software.
+LEGAL ISSUES        Copyright, lack of warranty, terms of distribution.
+REFERENCES          Where to learn more about JPEG.
+ARCHIVE LOCATIONS   Where to find newer versions of this software.
+RELATED SOFTWARE    Other stuff you should get.
+FILE FORMAT WARS    Software *not* to get.
+TO DO               Plans for future IJG releases.
+
+Other documentation files in the distribution are:
+
+User documentation:
+  install.doc       How to configure and install the IJG software.
+  usage.doc         Usage instructions for cjpeg, djpeg, rdjpgcom, wrjpgcom.
+  *.1               Unix-style man pages for programs (same info as usage.doc).
+  change.log        Version-to-version change highlights.
+Programmer and internal documentation:
+  libjpeg.doc       How to use the JPEG library in your own programs.
+  example.c         Sample code for calling the JPEG library.
+  structure.doc     Overview of the JPEG library's internal structure.
+  filelist.doc      Road map of IJG files.
+  coderules.doc     Coding style rules --- please read if you contribute code.
+
+Please read at least the files install.doc and usage.doc.  Useful information
+can also be found in the JPEG FAQ (Frequently Asked Questions) article.  See
+ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.
+
+If you want to understand how the JPEG code works, we suggest reading one or
+more of the REFERENCES, then looking at the documentation files (in roughly
+the order listed) before diving into the code.
+
+
+OVERVIEW
+========
+
+This package contains C software to implement JPEG image compression and
+decompression.  JPEG (pronounced "jay-peg") is a standardized compression
+method for full-color and gray-scale images.  JPEG is intended for compressing
+"real-world" scenes; cartoons and other non-realistic images are not its
+strong suit.  JPEG is lossy, meaning that the output image is not necessarily
+identical to the input image.  Hence you must not use JPEG if you have to have
+identical output bits.  However, on typical images of real-world scenes, very
+good compression levels can be obtained with no visible change, and amazingly
+high compression levels are possible if you can tolerate a low-quality image.
+For more details, see the references, or just experiment with various
+compression settings.
+
+We provide a set of library routines for reading and writing JPEG image files,
+plus two simple applications "cjpeg" and "djpeg", which use the library to
+perform conversion between JPEG and some other popular image file formats.
+The library is intended to be reused in other applications.
+
+This software implements JPEG baseline and extended-sequential compression
+processes.  Provision is made for supporting all variants of these processes,
+although some uncommon parameter settings aren't implemented yet.  For legal
+reasons, we are not distributing code for the arithmetic-coding process; see
+LEGAL ISSUES.  At present we have made no provision for supporting the
+progressive, hierarchical, or lossless processes defined in the standard.
+(Support for progressive mode may be offered in a future release.)
+
+In order to support file conversion and viewing software, we have included
+considerable functionality beyond the bare JPEG coding/decoding capability;
+for example, the color quantization modules are not strictly part of JPEG
+decoding, but they are essential for output to colormapped file formats or
+colormapped displays.  These extra functions can be compiled out of the
+library if not required for a particular application.  We have also included
+two simple applications for inserting and extracting textual comments in
+JFIF files.
+
+The emphasis in designing this software has been on achieving portability and
+flexibility, while also making it fast enough to be useful.  In particular,
+the software is not intended to be read as a tutorial on JPEG.  (See the
+REFERENCES section for introductory material.)  While we hope that the entire
+package will someday be industrial-strength code, much remains to be done in
+performance tuning and in improving the capabilities of individual modules.
+
+We welcome the use of this software as a component of commercial products.
+No royalty is required, but we do ask for an acknowledgement in product
+documentation, as described under LEGAL ISSUES.
+
+
+LEGAL ISSUES
+============
+
+In plain English:
+
+1. We don't promise that this software works.  (But if you find any bugs,
+   please let us know!)
+2. You can use this software for whatever you want.  You don't have to pay us.
+3. You may not pretend that you wrote this software.  If you use it in a
+   program, you must acknowledge somewhere in your documentation that
+   you've used the IJG code.
+
+In legalese:
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose.  This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991, 1992, 1993, 1994, Thomas G. Lane.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+These conditions apply to any software derived from or based on the IJG code,
+not just to the unmodified library.  If you use our work, you ought to
+acknowledge us.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it.  This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
+sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
+ansi2knr.c is NOT covered by the above copyright and conditions, but instead
+by the usual distribution terms of the Free Software Foundation; principally,
+that you must include source code if you redistribute it.  (See the file
+ansi2knr.c for full details.)  However, since ansi2knr.c is not needed as part
+of any program generated from the IJG code, this does not limit you more than
+the foregoing paragraphs do.
+
+The configuration script "configure" was produced by GNU Autoconf.  Again,
+the FSF copyright terms apply only to configure, not to the IJG code; and
+again, that does not limit your use of the object code.
+
+It appears that the arithmetic coding option of the JPEG spec is covered by
+patents owned by IBM, AT&T, and Mitsubishi.  Hence arithmetic coding cannot
+legally be used without obtaining one or more licenses.  For this reason,
+support for arithmetic coding has been removed from the free JPEG software.
+(Since arithmetic coding provides only a marginal gain over the unpatented
+Huffman mode, it is unlikely that very many implementations will support it.)
+So far as we are aware, there are no patent restrictions on the remaining
+code.
+
+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."
+
+
+REFERENCES
+==========
+
+We highly recommend reading one or more of these references before trying to
+understand the innards of the JPEG software.
+
+The best short technical introduction to the JPEG compression algorithm is
+	Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+(Adjacent articles in that issue discuss MPEG motion picture compression,
+applications of JPEG, and related topics.)  If you don't have the CACM issue
+handy, a PostScript file containing a revised version of Wallace's article is
+available at ftp.uu.net, graphics/jpeg/wallace.ps.gz.  The file (actually a
+preprint for an article to appear in IEEE Trans. Consumer Electronics) omits
+the sample images that appeared in CACM, but it includes corrections and some
+added material.  Note: the Wallace article is copyright ACM and IEEE, and it
+may not be used for commercial purposes.
+
+A somewhat less technical, more leisurely introduction to JPEG can be found in
+"The Data Compression Book" by Mark Nelson, published by M&T Books (Redwood
+City, CA), 1991, ISBN 1-55851-216-0.  This book provides good explanations and
+example C code for a multitude of compression methods including JPEG.  It is
+an excellent source if you are comfortable reading C code but don't know much
+about data compression in general.  The book's JPEG sample code is far from
+industrial-strength, but when you are ready to look at a full implementation,
+you've got one here...
+
+The best full description of JPEG is the textbook "JPEG Still Image Data
+Compression Standard" by William B. Pennebaker and Joan L. Mitchell, published
+by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.  Price US$59.95, 638 pp.
+The book includes the complete text of the ISO JPEG standards (DIS 10918-1
+and draft DIS 10918-2).  This is by far the most complete exposition of JPEG
+in existence, and we highly recommend it.
+
+The JPEG standard itself is not available electronically; you must order a
+paper copy through ISO.  (Unless you feel a need to own a certified official
+copy, we recommend buying the Pennebaker and Mitchell book instead; it's much
+cheaper and includes a great deal of useful explanatory material.)  In the US,
+copies of the standard may be ordered from ANSI Sales at (212) 642-4900, or
+from Global Engineering Documents at (800) 854-7179.  (ANSI doesn't take
+credit card orders, but Global does.)  It's not cheap: as of 1992, ANSI was
+charging $95 for Part 1 and $47 for Part 2, plus 7% shipping/handling.  The
+standard is divided into two parts, Part 1 being the actual specification,
+while Part 2 covers compliance testing methods.  Part 1 is titled "Digital
+Compression and Coding of Continuous-tone Still Images, Part 1: Requirements
+and guidelines" and has document number ISO/IEC IS 10918-1.  As of mid-1994,
+Part 2 is still at Draft International Standard status.  It is titled "Digital
+Compression and Coding of Continuous-tone Still Images, Part 2: Compliance
+testing" and has document number ISO/IEC DIS 10918-2.  (The document number
+will change to IS 10918-2 when final approval is obtained.)  A Part 3,
+covering extensions, is likely to appear in draft form in late 1994.
+
+The JPEG standard does not specify all details of an interchangeable file
+format.  For the omitted details we follow the "JFIF" conventions, revision
+1.02.  A copy of the JFIF spec is available from:
+	Literature Department
+	C-Cube Microsystems, Inc.
+	1778 McCarthy Blvd.
+	Milpitas, CA 95035
+	phone (408) 944-6300,  fax (408) 944-6314
+A PostScript version of this document is available at ftp.uu.net, file
+graphics/jpeg/jfif.ps.gz.  It can also be obtained by e-mail from the C-Cube
+mail server, netlib@c3.pla.ca.us.  Send the message "send jfif_ps from jpeg"
+to the server to obtain the JFIF document; send the message "help" if you have
+trouble.
+
+The TIFF 6.0 file format specification can be obtained by FTP from sgi.com
+(192.48.153.1), file graphics/tiff/TIFF6.ps.Z; or you can order a printed copy
+from Aldus Corp. at (206) 628-6593.  It should be noted that the TIFF 6.0 spec
+of 3-June-92 has a number of serious problems in its JPEG features.  A
+redesign effort is currently underway to correct these problems; it is
+expected to result in a new, incompatible, spec.  IJG intends to support the
+corrected version of TIFF when the new spec is issued.
+
+
+ARCHIVE LOCATIONS
+=================
+
+The "official" archive site for this software is ftp.uu.net (Internet
+address 192.48.96.9).  The most recent released version can always be found
+there in directory graphics/jpeg.  This particular version will be archived
+as graphics/jpeg/jpegsrc.v5.tar.gz.  If you are on the Internet, you
+can retrieve files from ftp.uu.net by standard anonymous FTP.  If you don't
+have FTP access, UUNET's archives are also available via UUCP; contact
+help@uunet.uu.net for information on retrieving files that way.
+
+Numerous Internet sites maintain copies of the UUNET files; in particular,
+you can probably find a copy at any site that archives comp.sources.misc
+submissions.  However, only ftp.uu.net is guaranteed to have the latest
+official version.
+
+You can also obtain this software from CompuServe, in the GRAPHSUPPORT forum
+(GO GRAPHSUP); this version will be file jpsrc5.zip in library 15.  Again,
+CompuServe is not guaranteed to have the very latest version.
+
+The JPEG FAQ (Frequently Asked Questions) article is a useful source of
+general information about JPEG.  It is updated constantly and therefore
+is not included in this distribution.  The FAQ is posted every two weeks
+to Usenet newsgroups comp.graphics, news.answers, and other groups.  You
+can always obtain the latest version from the news.answers archive at
+rtfm.mit.edu (18.181.0.24).  By FTP, fetch /pub/usenet/news.answers/jpeg-faq.
+If you don't have FTP, send e-mail to mail-server@rtfm.mit.edu with body
+"send usenet/news.answers/jpeg-faq".
+
+
+RELATED SOFTWARE
+================
+
+Numerous viewing and image manipulation programs now support JPEG.  (Quite a
+few of them use this library to do so.)  The JPEG FAQ described above lists
+some of the more popular free and shareware viewers, and tells where to
+obtain them on Internet.
+
+If you are on a Unix machine, we highly recommend Jef Poskanzer's free
+PBMPLUS image software, which provides many useful operations on PPM-format
+image files.  In particular, it can convert PPM images to and from a wide
+range of other formats.  You can obtain this package by FTP from ftp.x.org
+(contrib/pbmplus*.tar.Z) or ftp.ee.lbl.gov (pbmplus*.tar.Z).  There is also
+a newer update of this package called NETPBM, available from
+wuarchive.wustl.edu under directory /graphics/graphics/packages/NetPBM/.
+Unfortunately PBMPLUS/NETPBM is not nearly as portable as the IJG software
+is; you are likely to have difficulty making it work on any non-Unix machine.
+
+A different free JPEG implementation, written by the PVRG group at Stanford,
+is available from havefun.stanford.edu in directory pub/jpeg.  This program
+is designed for research and experimentation rather than production use;
+it is slower, harder to use, and less portable than the IJG code, but it
+implements a larger subset of the JPEG standard.  In particular, it supports
+lossless JPEG.
+
+
+FILE FORMAT WARS
+================
+
+Some JPEG programs produce files that are not compatible with our library.
+The root of the problem is that the ISO JPEG committee failed to specify a
+concrete file format.  Some vendors "filled in the blanks" on their own,
+creating proprietary formats that no one else could read.  (For example, none
+of the early commercial JPEG implementations for the Macintosh were able to
+exchange compressed files.)
+
+The file format we have adopted is called JFIF (see REFERENCES).  This format
+has been agreed to by a number of major commercial JPEG vendors, and it has
+become the de facto standard.  JFIF is a minimal or "low end" representation.
+Work is also going forward to incorporate JPEG compression into the TIFF
+standard, for use in "high end" applications that need to record a lot of
+additional data about an image.  We intend to support TIFF in the future.
+We hope that these two formats will be sufficient and that other,
+incompatible JPEG file formats will not proliferate.
+
+Indeed, part of the reason for developing and releasing this free software is
+to help force rapid convergence to de facto standards for JPEG file formats.
+SUPPORT STANDARD, NON-PROPRIETARY FORMATS: demand JFIF or TIFF/JPEG!
+
+
+TO DO
+=====
+
+In future versions, we are considering supporting progressive JPEG
+compression, the upcoming JPEG Part 3 extensions, and other improvements.
+
+As always, speeding things up is high on our priority list.
+
+Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net.
-- 
GitLab