diff --git a/README b/README
new file mode 100644
index 0000000..9a2a1bb
--- /dev/null
+++ b/README
@@ -0,0 +1,391 @@
+The Independent JPEG Group's JPEG software
+==========================================
+
+README for release of  7-Oct-91
+===============================
+
+This distribution contains the first 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.
+
+This software is still undergoing revision.  Updated versions may be obtained
+by anonymous FTP to uunet.uu.net; look under directory /graphics/jpeg.  This
+particular version will be archived as jpegsrc.v1.tar.Z.  If you don't have
+access to Internet FTP, UUNET's archives are also available via UUCP; contact
+postmaster@uunet.uu.net for information on retrieving files that way.
+
+Please report any problems with this software to jpeg-info@uunet.uu.net.
+
+If you intend to become a serious user of this software, please contact
+jpeg-info@uunet 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, 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.)
+
+
+WHAT'S HERE
+===========
+
+This distribution contains software to implement JPEG image compression and
+decompression.  JPEG 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 hardly any 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 or lossless processes defined in the standard.
+
+The present software is still largely in 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 SETUP), compile and go.
+  Members of the independent JPEG group will improve the out-of-the-box
+  functionality 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 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 the basis for commercial
+products; no royalty is required.
+
+
+SETUP
+=====
+
+The installation process is not very automatic; you will need at least some
+familiarity with C programming and program build procedures for your system.
+(Volunteers to work on improving this situation are welcome.  Also, we will
+probably start distributing pre-built binaries for popular systems at some
+point.)
+
+First, select a makefile and copy it to "Makefile".  "makefile.unix"
+is appropriate for most Unix and Unix-like systems.  Special makefiles are
+included for various PC compilers.  If you don't see a makefile for your
+system, we recommend starting from makefile.unix.
+
+Look over the Makefile and adjust options as needed.  In particular, you'll
+need to change the CC= and CFLAGS= definitions if you don't have gcc
+(makefile.unix only).  If you have a function-prototype-less compiler, be sure
+to uncomment the .c.o rule and say "make ansi2knr".  This will cause the
+source files to be preprocessed to change our ANSI-style function definitions
+to old-style definitions.  (Thanks to Peter Deutsch of Aladdin Enterprises for
+ansi2knr.)
+
+Also look over jconfig.h and adjust #defines as necessary.  If you have an
+ANSI-compliant C compiler (gcc for instance), no changes should be necessary
+except perhaps for RIGHT_SHIFT_IS_UNSIGNED and TWO_FILE_COMMANDLINE.  For
+older compilers other mods may be needed, depending on what ANSI features are
+supported.  If you prefer, you can usually leave jconfig.h unmodified and add
+-D switches to the Makefile's CFLAGS= definition.
+
+Then say "make".
+
+If you have trouble with missing system include files or inclusion of the
+wrong ones, you can fix it in jinclude.h.  In particular, if you are using
+gcc on a machine with non-ANSI system include files, you are likely to find
+that jinclude.h tries to include the wrong files (because gcc defines
+__STDC__).  There's no good automatic solution to this, so you'll just have
+to hand-edit jinclude.h.
+
+As a quick test of functionality we've included three sample files:
+	testorig.jpg	same as blkint.jpg from JPEG validation floppy.
+	testimg.ppm	output of djpeg testorig.jpg
+	testimg.jpg	output of cjpeg testimg.ppm
+The two .jpg files aren't identical due to different parameter choices (and
+wouldn't be anyway, since JPEG is lossy).  However, if you can generate
+duplicates of testimg.ppm and testimg.jpg then you probably have a working
+port.  "make test" will perform the necessary comparisons (by generating
+testout.ppm and testout.jpg and comparing these to testimg.*).  NOTE: this
+is far from an exhaustive test of the JPEG software; some modules, such as
+color quantization and GIF I/O, are not exercised at all.  It's just a quick
+test to give you some confidence that you haven't missed something major.
+
+If you need to make a smaller version of the JPEG software, some optional
+functions can be removed at compile time.  See the xxx_SUPPORTED #defines
+in jconfig.h.  (Not a lot is actually removed right now, but as more optional
+stuff gets added, this mechanism will start to make a difference.)
+
+If you want to incorporate the JPEG code as subroutines in a larger program,
+we recommend that you make libjpeg.a.  Then use the .h files and libjpeg.a as
+your interface to the JPEG functions.  Your surrounding program will have to
+provide functionality similar to what's in jcmain.c or jdmain.c, and you may
+want to replace jerror.c and possibly other modules depending on your needs.
+See the "architecture" file for more info.  If it seems to you that the system
+structure doesn't accommodate what you want to do, please contact the authors.
+
+Special notes for Macintosh Think C users: If you have version 5.0 you should
+be able to just turn on __STDC__ through the compiler switch that enables
+that.  With version 4.0 you must manually edit jconfig.h to define PROTO,
+HAVE_UNSIGNED_CHAR, HAVE_UNSIGNED_SHORT, and const.  (It seems to be safe to
+just define __STDC__ to take care of the first three.)  When setting up
+project files, use the COBJECTS and DOBJECTS lists in makefile.unix as a guide
+to which files need to be included, and add the ANSI and Unix C libraries in a
+separate segment.  You may need to divide the JPEG files into more than one
+segment; you can do this pretty much as you please.
+
+
+USAGE
+=====
+
+The user interface is pretty minimal at this point.  We haven't bothered to
+generate manual-page files since the switches badly need redesign.  At the
+moment, things work like this:
+
+There are two programs, cjpeg to compress an image file into JPEG format,
+and djpeg to decompress.
+
+On Unix systems, you say:
+	cjpeg [switches] [imagefile] >jpegfile
+	djpeg [switches] [jpegfile]  >imagefile
+The programs read the specified input file, or standard input if none is
+named.  They always write to standard output (with trace/error messages to
+standard error).  These conventions are handy for piping images between
+programs.
+
+On PC, Macintosh, and Amiga systems, you say:
+	cjpeg [switches] imagefile jpegfile
+	djpeg [switches] jpegfile  imagefile
+i.e., both input and output files are named on the command line.  This style
+is a little more foolproof, and it loses no functionality if you don't have
+pipes.  You can get this style on Unix too, if you prefer, by defining
+TWO_FILE_COMMANDLINE in jconfig.h or in the Makefile.  You MUST use this style
+on any system that doesn't cope well with binary data fed through
+stdin/stdout.
+
+Currently supported image file formats include raw-format PPM, raw-format PGM
+(for monochrome images), and GIF.  cjpeg recognizes the input image format
+automatically, but you have to tell djpeg which format to generate.
+
+The only JPEG file format currently supported is a raw JPEG data stream.
+Unless modified, the programs use the JFIF conventions for variables left
+unspecified by the JPEG standard.  (In particular, cjpeg generates a JFIF APP0
+marker.)  Support for the JPEG-in-TIFF format will probably be added at some
+future date.
+
+The command line switches for cjpeg are:
+
+	-I		Generate noninterleaved JPEG file (not yet supported).
+
+	-Q quality	Scale quantization tables to adjust quality.
+			Quality is 0 (worst) to 100 (best); default is 75.
+			(See below for more info.)
+
+	-a		Use arithmetic coding rather than Huffman coding.
+			(Not currently supported, see LEGAL ISSUES.)
+
+	-o		Perform optimization of entropy encoding parameters.
+			Without this, default Huffman or arithmetic
+			parameters are used.  -o makes the JPEG file a tad
+			smaller, but compression uses much more memory.
+			Image quality is unaffected by -o.
+
+	-d		Enable debug printout.  More -d's give more printout.
+
+Typically you'd use -Q settings of 50 or 75 or so.  -Q 100 will generate a
+quantization table of all 1's, meaning no quantization loss; then any
+differences between input and output images are due to subsampling or to
+roundoff error in the DCT or colorspace-conversion steps.  -Q values below 50
+may be useful for making real small, low-quality images.  Try -Q 2 (or so) for
+some amusing Cubist effects.  (Note that -Q values below about 25 generate
+2-byte quantization tables, which are not decodable by pure baseline JPEG
+decoders.  cjpeg emits a warning message when you give such a -Q value.)
+
+The command line switches for djpeg are:
+
+	-G		Select GIF output format (implies -q, with default
+			of 256 colors).
+
+	-b		Perform cross-block smoothing.  This is quite
+			memory-intensive and only seems to improve the image
+			at very low quality settings (-Q 10 to 20 or so).
+
+	-g		Force gray-scale output even if input is color.
+
+	-q N		Quantize to N colors.
+
+	-D		Use Floyd-Steinberg dithering in color quantization.
+
+	-2		Use two-pass color quantization (not yet supported).
+
+	-d		Enable debug printout.  More -d's give more printout.
+
+Color quantization currently uses a rather shoddy algorithm (although it's not
+so horrible when dithered).  Because of this, the GIF output mode is not
+recommended in the current release, except for gray-scale output.  You can get
+better results by applying ppmquant to the unquantized (PPM) output of djpeg,
+then converting to GIF with ppmtogif.  We expect to provide a considerably
+better quantization algorithm in a future release.
+
+Note that djpeg *can* read noninterleaved JPEG files even though cjpeg can't
+yet generate them.  For most applications this is a nonissue, since hardly
+anybody seems to be using noninterleaved format.
+
+On a non-virtual-memory machine, you may run out of memory if you use -I or -o
+in cjpeg, or -q ... -2 in djpeg, or try to read an interlaced GIF file.  This
+will be addressed eventually by replacing jvirtmem.c with something that uses
+temporary files for large images (see TO DO).
+
+
+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 looking at any of the JPEG software.
+
+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 current version is ISO/IEC Committee Draft CD 10918-1 dated 1991-03-15.
+The standard is not presently available electronically; you must order a paper
+copy through ISO.
+
+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
+Requests can also be e-mailed to info@c3.pla.ca.us (this address good after
+10/10/91).  The same source can supply copies of the draft JPEG-in-TIFF specs.
+
+If you want to understand this implementation, start by reading the
+"architecture" documentation file.  Please read "codingrules" if you want to
+contribute any code.
+
+
+SUPPORTING SOFTWARE
+===================
+
+You will probably want Jef Poskanzer's PBMPLUS image software; this 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).
+
+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.
+
+
+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, 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 held by IBM, and possibly also patents of 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
+people will choose to use it.  If you do obtain such a license, 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.
+
+
+TO DO
+=====
+
+Many of the modules need fleshing out to provide more complete
+implementations, or to provide faster paths for common cases.  The greatest
+needs are for (a) decent color quantization, and (b) a memory manager
+implementation that can work in limited memory by swapping "big" images to
+temporary files.  I (Tom Lane) am going to work on color quantization next.
+Volunteers to write a PC memory manager, or to work on any other modules, are
+welcome.
+
+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/ansi2knr.c b/ansi2knr.c
new file mode 100644
index 0000000..77d3d81
--- /dev/null
+++ b/ansi2knr.c
@@ -0,0 +1,477 @@
+/*
+ * Received from Peter Deutsch (ghost@aladdin.com)
+ * Fri, 26 Apr 91 10:10:10 PDT
+ */
+
+/* Copyright (C) 1989, 1991 Aladdin Enterprises.  All rights reserved.
+   Distributed by Free Software Foundation, Inc.
+
+This file is part of Ghostscript.
+
+Ghostscript is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
+to anyone for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.  Refer
+to the Ghostscript General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute
+Ghostscript, but only under the conditions described in the Ghostscript
+General Public License.  A copy of this license is supposed to have been
+given to you along with Ghostscript so you can know your rights and
+responsibilities.  It should be in a file named COPYING.  Among other
+things, the copyright notice and this notice must be preserved on all
+copies.  */
+
+/*
+---------- Here is the GhostScript file COPYING, referred to above ----------
+----- These terms do NOT apply to the JPEG software itself; see README ------
+
+		    GHOSTSCRIPT GENERAL PUBLIC LICENSE
+		    (Clarified 11 Feb 1988)
+
+ Copyright (C) 1988 Richard M. Stallman
+ Everyone is permitted to copy and distribute verbatim copies of this
+ license, but changing it is not allowed.  You can also use this wording
+ to make the terms for other programs.
+
+  The license agreements of most software companies keep you at the
+mercy of those companies.  By contrast, our general public license is
+intended to give everyone the right to share Ghostscript.  To make sure
+that you get the rights we want you to have, we need to make
+restrictions that forbid anyone to deny you these rights or to ask you
+to surrender the rights.  Hence this license agreement.
+
+  Specifically, we want to make sure that you have the right to give
+away copies of Ghostscript, that you receive source code or else can get
+it if you want it, that you can change Ghostscript or use pieces of it
+in new free programs, and that you know you can do these things.
+
+  To make sure that everyone has such rights, we have to forbid you to
+deprive anyone else of these rights.  For example, if you distribute
+copies of Ghostscript, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must tell them their rights.
+
+  Also, for our own protection, we must make certain that everyone finds
+out that there is no warranty for Ghostscript.  If Ghostscript is
+modified by someone else and passed on, we want its recipients to know
+that what they have is not what we distributed, so that any problems
+introduced by others will not reflect on our reputation.
+
+  Therefore we (Richard M. Stallman and the Free Software Foundation,
+Inc.) make the following terms which say what you must do to be allowed
+to distribute or change Ghostscript.
+
+
+			COPYING POLICIES
+
+  1. You may copy and distribute verbatim copies of Ghostscript source
+code as you receive it, in any medium, provided that you conspicuously
+and appropriately publish on each copy a valid copyright and license
+notice "Copyright (C) 1989 Aladdin Enterprises.  All rights reserved.
+Distributed by Free Software Foundation, Inc." (or with whatever year is
+appropriate); keep intact the notices on all files that refer to this
+License Agreement and to the absence of any warranty; and give any other
+recipients of the Ghostscript program a copy of this License Agreement
+along with the program.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of Ghostscript or any portion of
+it, and copy and distribute such modifications under the terms of
+Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of Ghostscript
+    or any part thereof, to be licensed at no charge to all third
+    parties on terms identical to those contained in this License
+    Agreement (except that you may choose to grant more extensive
+    warranty protection to some or all third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+  3. You may copy and distribute Ghostscript (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the
+terms of Paragraphs 1 and 2 above provided that you also do one of the
+following:
+
+    a) accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    b) accompany it with a written offer, valid for at least three
+    years, to give any third party free (except for a nominal
+    shipping charge) a complete machine-readable copy of the
+    corresponding source code, to be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    c) accompany it with the information you received as to where the
+    corresponding source code may be obtained.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
+
+  4. You may not copy, sublicense, distribute or transfer Ghostscript
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer Ghostscript is
+void and your rights to use the program under this License agreement
+shall be automatically terminated.  However, parties who have received
+computer software programs from you with this License Agreement will not
+have their licenses terminated so long as such parties remain in full
+compliance.
+
+  5. If you wish to incorporate parts of Ghostscript into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not
+yet worked out a simple rule that can be stated here, but we will often
+permit this.  We will be guided by the two goals of preserving the free
+status of all derivatives of our free software and of promoting the
+sharing and reuse of software.
+
+Your comments and suggestions about our licensing policies and our
+software are welcome!  Please contact the Free Software Foundation,
+Inc., 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296.
+
+		       NO WARRANTY
+
+  BECAUSE GHOSTSCRIPT IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, RICHARD
+M. STALLMAN, ALADDIN ENTERPRISES, L. PETER DEUTSCH, AND/OR OTHER PARTIES
+PROVIDE GHOSTSCRIPT "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
+EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE
+ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF GHOSTSCRIPT IS WITH
+YOU.  SHOULD GHOSTSCRIPT PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
+NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., L. PETER DEUTSCH, ALADDIN
+ENTERPRISES, AND/OR ANY OTHER PARTY WHO MAY MODIFY AND REDISTRIBUTE
+GHOSTSCRIPT AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
+ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
+(INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
+INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE
+PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GHOSTSCRIPT, EVEN IF YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM
+BY ANY OTHER PARTY.
+-------------------- End of file COPYING ------------------------------
+*/
+
+
+/* ansi2knr.c */
+/* Convert ANSI function declarations to K&R syntax */
+#include <stdio.h>
+#include <ctype.h>
+
+#ifdef BSD
+#  include <strings.h>
+#  define strchr index
+#else
+#  ifdef VMS
+	extern char *strcat(), *strchr(), *strcpy(), *strupr();
+	extern int strcmp(), strlen(), strncmp();
+#  else
+#    include <string.h>
+#  endif
+#endif
+
+#ifdef MSDOS
+#  include <malloc.h>
+#else
+#  ifdef VMS
+     extern char *malloc();
+     extern void free();
+#  else
+#    ifdef BSD
+       extern char *malloc();
+#    else
+#      include <malloc.h>
+#    endif
+#  endif
+#endif
+
+/* Usage:
+	ansi2knr input_file output_file
+ * If no output_file is supplied, output goes to stdout.
+ * There are no error messages.
+ *
+ * ansi2knr recognizes functions by seeing a non-keyword identifier
+ * at the left margin, followed by a left parenthesis,
+ * with a right parenthesis as the last character on the line.
+ * It will recognize a multi-line header if the last character
+ * on each line but the last is a left parenthesis or comma.
+ * These algorithms ignore whitespace and comments, except that
+ * the function name must be the first thing on the line.
+ * The following constructs will confuse it:
+	- Any other construct that starts at the left margin and
+	    follows the above syntax (such as a macro or function call).
+	- Macros that tinker with the syntax of the function header.
+ */
+
+/* Scanning macros */
+#define isidchar(ch) (isalnum(ch) || (ch) == '_')
+#define isidfirstchar(ch) (isalpha(ch) || (ch) == '_')
+
+main(argc, argv)
+    int argc;
+    char *argv[];
+{	FILE *in, *out;
+#define bufsize 500			/* arbitrary size */
+	char buf[bufsize];
+	char *line;
+	switch ( argc )
+	   {
+	default:
+		printf("Usage: ansi2knr input_file [output_file]\n");
+		exit(0);
+	case 2:
+		out = stdout; break;
+	case 3:
+		out = fopen(argv[2], "w");
+		if ( out == NULL )
+		   {	fprintf(stderr, "Cannot open %s\n", argv[2]);
+			exit(1);
+		   }
+	   }
+	in = fopen(argv[1], "r");
+	if ( in == NULL )
+	   {	fprintf(stderr, "Cannot open %s\n", argv[1]);
+		exit(1);
+	   }
+	fprintf(out, "#line 1 \"%s\"\n", argv[1]);
+	line = buf;
+	while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
+	   {	switch ( test1(buf) )
+		   {
+		case 1:			/* a function */
+			convert1(buf, out);
+			break;
+		case -1:		/* maybe the start of a function */
+			line = buf + strlen(buf);
+			continue;
+		default:		/* not a function */
+			fputs(buf, out);
+			break;
+		   }
+		line = buf;
+	   }
+	if ( line != buf ) fputs(buf, out);
+	fclose(out);
+	fclose(in);
+	return 0;
+}
+
+/* Skip over space and comments, in either direction. */
+char *
+skipspace(p, dir)
+    register char *p;
+    register int dir;			/* 1 for forward, -1 for backward */
+{	for ( ; ; )
+	   {	while ( isspace(*p) ) p += dir;
+		if ( !(*p == '/' && p[dir] == '*') ) break;
+		p += dir;  p += dir;
+		while ( !(*p == '*' && p[dir] == '/') )
+		   {	if ( *p == 0 ) return p;	/* multi-line comment?? */
+			p += dir;
+		   }
+		p += dir;  p += dir;
+	   }
+	return p;
+}
+
+/*
+ * Write blanks over part of a string.
+ */
+void
+writeblanks(start, end)
+    char *start;
+    char *end;
+{	char *p;
+	for ( p = start; p < end; p++ ) *p = ' ';
+}
+
+/*
+ * Test whether the string in buf is a function definition.
+ * The string may contain and/or end with a newline.
+ * Return as follows:
+ *	0 - definitely not a function definition;
+ *	1 - definitely a function definition;
+ *	-1 - may be the beginning of a function definition,
+ *		append another line and look again.
+ */
+test1(buf)
+    char *buf;
+{	register char *p = buf;
+	char *bend;
+	char *endfn;
+	int contin;
+	if ( !isidfirstchar(*p) )
+		return 0;		/* no name at left margin */
+	bend = skipspace(buf + strlen(buf) - 1, -1);
+	switch ( *bend )
+	   {
+	case ')': contin = 1; break;
+	case '(':
+	case ',': contin = -1; break;
+	default: return 0;		/* not a function */
+	   }
+	while ( isidchar(*p) ) p++;
+	endfn = p;
+	p = skipspace(p, 1);
+	if ( *p++ != '(' )
+		return 0;		/* not a function */
+	p = skipspace(p, 1);
+	if ( *p == ')' )
+		return 0;		/* no parameters */
+	/* Check that the apparent function name isn't a keyword. */
+	/* We only need to check for keywords that could be followed */
+	/* by a left parenthesis (which, unfortunately, is most of them). */
+	   {	static char *words[] =
+		   {	"asm", "auto", "case", "char", "const", "double",
+			"extern", "float", "for", "if", "int", "long",
+			"register", "return", "short", "signed", "sizeof",
+			"static", "switch", "typedef", "unsigned",
+			"void", "volatile", "while", 0
+		   };
+		char **key = words;
+		char *kp;
+		int len = endfn - buf;
+		while ( (kp = *key) != 0 )
+		   {	if ( strlen(kp) == len && !strncmp(kp, buf, len) )
+				return 0;	/* name is a keyword */
+			key++;
+		   }
+	   }
+	return contin;
+}
+
+convert1(buf, out)
+    char *buf;
+    FILE *out;
+{	char *endfn = strchr(buf, '(') + 1;
+	register char *p;
+	char **breaks;
+	unsigned num_breaks = 2;	/* for testing */
+	char **btop;
+	char **bp;
+	char **ap;
+top:	p = endfn;
+	breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
+	if ( breaks == 0 )
+	   {	/* Couldn't allocate break table, give up */
+		fprintf(stderr, "Unable to allocate break table!\n");
+		fputs(buf, out);
+		return -1;
+	   }
+	btop = breaks + num_breaks * 2 - 2;
+	bp = breaks;
+	/* Parse the argument list */
+	do
+	   {	int level = 0;
+		char *end = NULL;
+		if ( bp >= btop )
+		   {	/* Filled up break table. */
+			/* Allocate a bigger one and start over. */
+			free((char *)breaks);
+			num_breaks <<= 1;
+			goto top;
+		   }
+		*bp++ = p;
+		/* Find the end of the argument */
+		for ( ; end == NULL; p++ )
+		   {	switch(*p)
+			   {
+			case ',': if ( !level ) end = p; break;
+			case '(': level++; break;
+			case ')': if ( --level < 0 ) end = p; break;
+			case '/': p = skipspace(p, 1) - 1; break;
+			default: ;
+			   }
+		   }
+		p--;			/* back up over terminator */
+		/* Find the name being declared. */
+		/* This is complicated because of procedure and */
+		/* array modifiers. */
+		for ( ; ; )
+		   {	p = skipspace(p - 1, -1);
+			switch ( *p )
+			   {
+			case ']':	/* skip array dimension(s) */
+			case ')':	/* skip procedure args OR name */
+			   {	int level = 1;
+				while ( level )
+				 switch ( *--p )
+				   {
+				case ']': case ')': level++; break;
+				case '[': case '(': level--; break;
+				case '/': p = skipspace(p, -1) + 1; break;
+				default: ;
+				   }
+			   }
+				if ( *p == '(' && *skipspace(p + 1, 1) == '*' )
+				   {	/* We found the name being declared */
+					while ( !isidfirstchar(*p) )
+						p = skipspace(p, 1) + 1;
+					goto found;
+				   }
+				break;
+			default: goto found;
+			   }
+		   }
+found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
+		   {	p++;
+			if ( bp == breaks + 1 )	/* sole argument */
+				writeblanks(breaks[0], p);
+			else
+				writeblanks(bp[-1] - 1, p);
+			bp--;
+		   }
+		else
+		   {	while ( isidchar(*p) ) p--;
+			*bp++ = p+1;
+		   }
+		p = end;
+	   }
+	while ( *p++ == ',' );
+	*bp = p;
+	/* Make a special check for 'void' arglist */
+	if ( bp == breaks+2 )
+	   {	p = skipspace(breaks[0], 1);
+		if ( !strncmp(p, "void", 4) )
+		   {	p = skipspace(p+4, 1);
+			if ( p == breaks[2] - 1 )
+			   {	bp = breaks;	/* yup, pretend arglist is empty */
+				writeblanks(breaks[0], p + 1);
+			   }
+		   }
+	   }
+	/* Put out the function name */
+	p = buf;
+	while ( p != endfn ) putc(*p, out), p++;
+	/* Put out the declaration */
+	for ( ap = breaks+1; ap < bp; ap += 2 )
+	   {	p = *ap;
+		while ( isidchar(*p) ) putc(*p, out), p++;
+		if ( ap < bp - 1 ) fputs(", ", out);
+	   }
+	fputs(")  ", out);
+	/* Put out the argument declarations */
+	for ( ap = breaks+2; ap <= bp; ap += 2 ) (*ap)[-1] = ';';
+	fputs(breaks[0], out);
+	free((char *)breaks);
+	return 0;
+}
diff --git a/architecture b/architecture
new file mode 100644
index 0000000..78587cd
--- /dev/null
+++ b/architecture
@@ -0,0 +1,1106 @@
+
+	JPEG SYSTEM ARCHITECTURE		3-OCT-91
+
+
+This file provides an overview of the "architecture" of the portable JPEG
+software; that is, the functions of the various modules in the system and the
+interfaces between modules.  For more precise details about any data structure
+or calling convention, see the header files.
+
+Important note: when I say "module" I don't mean "a C function", which is what
+some people seem to think the term means.  A separate C source file is closer
+to the mark.  Also, it is frequently the case that several different modules
+present a common interface to callers; the term "object" or "method" refers to
+this common interface (see "Poor man's object-oriented programming", below).
+
+JPEG-specific terminology follows the JPEG R9 draft:
+  A "component" means a color channel, e.g., Red or Luminance.
+  A "sample" is a pixel component value (i.e., one number in the image data).
+  A "coefficient" is a frequency coefficient (a DCT transform output number).
+  The term "block" refers to an 8x8 group of samples or coefficients.
+  "MCU" (minimum coded unit) is the same as "MDU" of the R8 draft; i.e., an
+	interleaved set of blocks of size determined by the sampling factors,
+	or a single block in a noninterleaved scan.
+
+
+*** System requirements ***
+
+We must support compression and decompression of both Huffman and
+arithmetic-coded JPEG files.  Any set of compression parameters allowed by the
+JPEG spec should be readable for decompression.  (We can be more restrictive
+about what formats we can generate.)  (Note: for legal reasons no arithmetic
+coding implementation is currently included in the publicly available sources.
+However, the architecture still supports it.)
+
+We need to be able to handle both raw JPEG files (more specifically, the JFIF
+format) and JPEG-in-TIFF (C-cubed's format, and perhaps Kodak's).  Even if we
+don't implement TIFF ourselves, other people will want to use our code for
+that.  This means that generation and scanning of the file header has to be
+separated out.
+
+Perhaps we should be prepared to support the JPEG lossless mode (also referred
+to in the spec as spatial DPCM coding).  A lot of people seem to believe they
+need this... whether they really do is debatable, but the customer is always
+right.  On the other hand, there will not be much sharable code between the
+lossless and lossy modes!  At best, a lossless program could be derived from
+parts of the lossy version.  For now we will only worry about the lossy mode.
+
+I see no real value in supporting the JPEG progressive modes (note that
+spectral selection and successive approximation are two different progressive
+modes).  These are only of interest when painting the decompressed image in
+real-time, which nobody is going to do with a pure software implementation.
+
+There is some value in supporting the hierarchical mode, which allows for
+successive frames of higher resolution.  This could be of use for including
+"thumbnail" representations.  Also, Storm's JPEG++ files probably use the
+hierarchical mode (I haven't looked).  However, this appears to add a lot more
+complexity than it is worth.
+
+A variety of uncompressed image file formats and user interfaces must be
+supported.  These aspects therefore have to be kept separate from the rest of
+the system.  A particularly important issue is whether color quantization of
+the output is needed (i.e., whether a colormap is used).  We should be able to
+support both adaptive quantization (which requires two or more passes over the
+image) and nonadaptive (quantization to a prespecified colormap, which can be
+done in one pass).
+
+Memory usage is an important concern, since we will port this code to 80x86
+and other limited-memory machines.  For large intermediate structures, we
+should be able to use either virtual memory or temporary files.
+
+It should be possible to build programs that handle compression only,
+decompression only, or both, without much duplicate or unused code in any
+version.  (In particular, a decompression-only version should have no extra
+baggage.)
+
+
+*** Compression overview ***
+
+The *logical* steps needed in (non-lossless) JPEG compression are:
+
+1. Conversion from incoming image format to a standardized internal form
+   (either RGB or greyscale).
+
+2. Color space conversion (e.g., RGB to YCbCr).  This is a null step for
+   greyscale (unless we support mapping color inputs to greyscale, which
+   would most easily be done here).  Gamma adjustment may also be needed here.
+
+3. Subsampling (reduction of number of samples in some color components).
+   This step operates independently on each color component.
+
+4. MCU extraction (creation of a single sequence of 8x8 sample blocks).
+   This step and the following ones are performed once for each scan
+   in the output JPEG file, i.e., once if making an interleaved file and more
+   than once for a noninterleaved file.
+   Note: both this step and the previous one must deal with edge conditions
+   for pictures that aren't a multiple of the MCU dimensions.  Alternately,
+   we could expand the picture to a multiple of an MCU before doing these
+   two steps.  (The latter seems better and has been adopted below.)
+
+5. DCT transformation of each 8x8 block.
+
+6. Quantization scaling and zigzag reordering of the elements in each 8x8
+   block.
+
+7. Huffman or arithmetic encoding of the transformed block sequence.
+
+8. Output of the JPEG file with whatever headers/markers are wanted.
+
+Of course, the actual implementation will combine some of these logical steps
+for efficiency.  The trick is to keep these logical functions as separate as
+possible without losing too much performance.
+
+In addition to these logical pipeline steps, we need various modules that
+aren't part of the data pipeline.  These are:
+
+A. Overall control (sequencing of other steps & management of data passing).
+
+B. User interface; this will determine the input and output files, and supply
+   values for some compression parameters.  Note that this module is highly
+   platform-dependent.
+
+C. Compression parameter selection: some parameters should be chosen
+   automatically rather than requiring the user to find a good value.
+   The prototype only does this for the back-end (Huffman or arithmetic)
+   parameters, but further in the future, more might be done.  A
+   straightforward approach to selection is to try several values; this
+   requires being able to repeatedly apply some portion of the pipeline and
+   inspect the results (without actually outputting them).  Probably only
+   entropy encoding parameters can reasonably be done this way; optimizing
+   earlier steps would require too much data to be reprocessed (not to mention
+   the problem of interactions between parameters for different steps).
+   What other facilities do we need to support automatic parameter selection?
+
+D. A memory management module to deal with small-memory machines.  This must
+   create the illusion of virtual memory for certain large data structures
+   (e.g., the subsampled image or the transformed coefficients).
+   The interface to this must be defined to minimize the overhead incurred,
+   especially on virtual-memory machines where the module won't do much.
+
+In many cases we can arrange things so that a data stream is produced in
+segments by one module and consumed by another without the need to hold it all
+in (virtual) memory.  This is obviously not possible for any data that must be
+scanned more than once, so it won't work everywhere.
+
+The major variable at this level of detail is whether the JPEG file is to be
+interleaved or not; that affects the order of processing so fundamentally that
+the central control module must know about it.  Some of the other modules may
+need to know it too.  It would simplify life if we didn't need to support
+noninterleaved images, but that is not reasonable.
+
+Many of these steps operate independently on each color component; the
+knowledge of how many components there are, and how they are interleaved,
+ought to be confined to the central control module.  (Color space conversion
+and MCU extraction probably have to know it too.)
+
+
+*** Decompression overview ***
+
+Decompression is roughly the inverse process from compression, but there are
+some additional steps needed to produce a good output image.
+
+The *logical* steps needed in (non-lossless) JPEG decompression are:
+
+1. Scanning of the JPEG file, decoding of headers/markers etc.
+
+2. Huffman or arithmetic decoding of the coefficient sequence.
+
+3. Quantization descaling and zigzag reordering of the elements in each 8x8
+   block.
+
+4. MCU disassembly (conversion of a possibly interleaved sequence of 8x8
+   blocks back to separate components in pixel map order).
+
+5. (Optional)  Cross-block smoothing per JPEG section 13.10 or a similar
+   algorithm.  (Steps 5-8 operate independently on each component.)
+
+6. Inverse DCT transformation of each 8x8 block.
+
+7. De-subsampling.  At this point a pixel image of the original dimensions
+   has been recreated.
+
+8. Post-subsampling smoothing.  This can be combined with de-subsampling,
+   by using a convolution-like calculation to generate each output pixel
+   directly from one or more input pixels.
+
+9. Cropping to the original pixel dimensions (throwing away duplicated
+   pixels at the edges).  It is most convenient to do this now, as the
+   preceding steps are simplified by not having to worry about odd picture
+   sizes.
+
+10. Color space reconversion (e.g., YCbCr to RGB).  This is a null step for
+    greyscale.  (Note that if we support mapping color JPEG to greyscale,
+    it could be done as part of this step.)  Gamma adjustment may also be
+    needed here.
+
+11. Color quantization (only if a colormapped output format is requested).
+    NOTE: it might be better to do this on the internal color space instead of
+    RGB?  If so, it would need to be performed one step earlier.
+
+12. Writing of the desired image format.
+
+As before, some of these will be combined into single steps.  When dealing
+with a noninterleaved JPEG file, steps 2-9 will be performed once for each
+scan; the resulting data will need to be buffered up so that step 10 can
+process all the color components together.
+
+The same auxiliary modules are needed as before, except for compression
+parameter selection.  Note that rerunning a pipeline stage should never be
+needed during decompression.  This may allow a simpler control module.  The
+user interface might also be simpler since it need not supply any compression
+parameters.
+
+As before, not all of these steps require the whole image to be stored.
+Actually, two-pass color quantization is the only step that logically requires
+this; everything else could be done a few raster lines at a time (at least for
+interleaved images).  We might want to make color quantization be a separate
+program because of this fact.
+
+Again, many of the steps should be able to work on one color component in
+ignorance of the other components.
+
+
+*** Implications of noninterleaved formats ***
+
+Much of the work can be done in a single pass if an interleaved JPEG file
+format is used.  With a noninterleaved JPEG file, separating or recombining
+the components will force use of virtual memory (on a small-memory machine,
+we probably would want one temp file per color component).
+
+If any of the image formats we read or write are noninterleaved, the opposite
+condition might apply: processing a noninterleaved JPEG file would be more
+efficient.  Offhand, though, I can't think of any popular image formats that
+work that way; besides the win would only come if the same color space were
+used in JPEG and non-JPEG files.  It's not worth the complexity to make the
+system design accommodate that case efficiently.
+
+An argument against interleaving is that it makes the decompressor need more
+memory for cross-block smoothing (since the minimum processable chunk of the
+image gets bigger).  With images more than 1000 pixels across, 80x86 machines
+are likely to have difficulty in handling this feature.
+
+Another argument against interleaving is that the noninterleaved format allows
+a wider range of sampling factors, since the limit of ten blocks per MCU no
+longer applies.  We could get around this by blithely ignoring the spec's
+limit of ten blocks, but that seems like a bad idea (especially since it makes
+the above problem worse).
+
+The upshot is that we need to support both interleaved and noninterleaved JPEG
+formats, since for any given machine and picture size one may be much more
+efficient than the other.  However, the non-JPEG format we convert to or from
+will be assumed to be an interleaved format (i.e., it produces or stores all
+the components of a pixel together).
+
+I do not think it is necessary for the compressor to be able to output
+partially-interleaved formats (multiple scans, some of which interleave a
+subset of the components).  However, the decompressor must be able to read
+such files to conform to the spec.
+
+
+*** Data formats ***
+
+Pipeline steps that work on pixel sample values will use the following data
+structure:
+
+    typedef something JSAMPLE;		a pixel component value, 0..MAXJSAMPLE
+    typedef JSAMPLE *JSAMPROW;		ptr to a row of samples
+    typedef JSAMPROW *JSAMPARRAY;	ptr to a list of rows
+    typedef JSAMPARRAY *JSAMPIMAGE;	ptr to a list of color-component arrays
+
+The basic element type JSAMPLE will be one of unsigned char, (signed) char, or
+unsigned short.  Unsigned short will be used if samples wider than 8 bits are
+to be supported (this is a compile-time option).  Otherwise, unsigned char is
+used if possible.  If the compiler only supports signed chars, then it is
+necessary to mask off the value when reading.  Thus, all reads of sample
+values should be coded as "GETJSAMPLE(value)", where the macro will be defined
+as "((value)&0xFF)" on signed-char machines and "(value)" elsewhere.
+
+With these conventions, JSAMPLE values can be assumed to be >= 0.  This should
+simplify correct rounding during subsampling, etc.  The JPEG draft's
+specification that sample values run from -128..127 will be accommodated by
+subtracting 128 just as the sample value is copied into the source array for
+the DCT step (this will be an array of signed shorts or longs).  Similarly,
+during decompression the output of the IDCT step will be immediately shifted
+back to 0..255.  (NB: different values are required when 12-bit samples are in
+use.  The code should be written in terms of MAXJSAMPLE and CENTERJSAMPLE,
+which will be #defined as 255 and 128 respectively in an 8-bit implementation,
+and as 4095 and 2048 in a 12-bit implementation.)
+
+On compilers that don't support "unsigned short", signed short can be used for
+a 12-bit implementation.  To support lossless coding (which allows up to
+16-bit data precision) masking with 0xFFFF in GETJSAMPLE might be necessary.
+(But if "int" is 16 bits then using "unsigned int" is the best solution.)
+
+Notice that we use a pointer per row, rather than a two-dimensional JSAMPLE
+array.  This choice costs only a small amount of memory and has several
+benefits:
+
+* Code using the data structure doesn't need to know the allocated width of
+the rows.  This will simplify edge expansion/compression, since we can work
+in an array that's wider than the logical picture width.
+
+* The rows forming a component array may be allocated at different times
+without extra copying.  This will simplify working a few scanlines at a time,
+especially in smoothing steps that need access to the previous and next rows.
+
+* Indexing doesn't require multiplication; this is a performance win on many
+machines.
+
+Note that each color component is stored in a separate array; we don't use the
+traditional structure in which the components of a pixel are stored together.
+This simplifies coding of steps that work on each component independently,
+because they don't need to know how many components there are.  Furthermore,
+we can read or write each component to a temp file independently, which is
+helpful when dealing with noninterleaved JPEG files.
+
+A specific sample value will be accessed by code such as
+	GETJSAMPLE(image[colorcomponent][row][col])
+where col is measured from the image left edge, but row is measured from the
+first sample row currently in memory.  Either of the first two indexings can
+be precomputed by copying the relevant pointer.
+
+
+Pipeline steps that work on frequency-coefficient values will use the
+following data structure:
+
+    typedef short JCOEF;		a 16-bit signed integer
+    typedef JCOEF JBLOCK[64];		an 8x8 block of coefficients
+    typedef JBLOCK *JBLOCKROW;		ptr to one horizontal row of 8x8 blocks
+    typedef JBLOCKROW *JBLOCKARRAY;	ptr to a list of such rows
+    typedef JBLOCKARRAY *JBLOCKIMAGE;	ptr to a list of color component arrays
+
+The underlying type is always a 16-bit signed integer (this is "short" on all
+machines of interest, but let's use the typedef name anyway).  These are
+grouped into 8x8 blocks (we should use #defines DCTSIZE and DCTSIZE2 rather
+than "8" and "64").  The contents of a block may be either in "natural" or
+zigzagged order, and may be true values or divided by the quantization
+coefficients, depending on where the block is in the pipeline.
+
+Notice that the allocation unit is now a row of 8x8 blocks, corresponding to
+eight rows of samples.  Otherwise the structure is much the same as for
+samples, and for the same reasons.
+
+On machines where malloc() can't handle a request bigger than 64Kb, this data
+structure limits us to rows of less than 512 JBLOCKs, which would be a picture
+width of 4000 pixels.  This seems an acceptable restriction.
+
+
+On 80x86 machines, the bottom-level pointer types (JSAMPROW and JBLOCKROW)
+must be declared as "far" pointers, but the upper levels can be "near"
+(implying that the pointer lists are allocated in the DS segment).
+To simplify sharing code, we'll have a #define symbol FAR, which expands to
+the "far" keyword when compiling on 80x86 machines and to nothing elsewhere.
+
+
+The data arrays used as input and output of the DCT transform subroutine will
+be declared using a separate typedef; they could be arrays of "short", "int"
+or "long" independently of the above choices.  This would depend on what is
+needed to make the compiler generate correct and efficient multiply/add code
+in the DCT inner loops.  No significant speed or memory penalty will be paid
+to have a different representation than is used in the main image storage
+arrays, since some additional value-by-value processing is done at the time of
+creation or extraction of the DCT data anyway (e.g., add/subtract 128).
+
+
+*** Poor man's object-oriented programming ***
+
+It should be pretty clear by now that we have a lot of quasi-independent
+steps, many of which have several possible behaviors.  To avoid cluttering the
+code with lots of switch statements, we'll use a simple form of object-style
+programming to separate out the different possibilities.
+
+For example, Huffman and arithmetic coding will be implemented as two separate
+modules that present the same external interface; at runtime, the calling code
+will access the proper module indirectly through an "object".
+
+We can get the limited features we need while staying within portable C.  The
+basic tool is a function pointer.  An "object" is just a struct containing one
+or more function pointer fields, each of which corresponds to a method name in
+real object-oriented languages.  During initialization we fill in the function
+pointers with references to whichever module we have determined we need to use
+in this run.  Then invocation of the module is done by indirecting through a
+function pointer; on most architectures this is no more expensive (and
+possibly cheaper) than a switch, which would be the only other way of making
+the required run-time choice.  The really significant benefit, of course, is
+keeping the source code clean and well structured.
+
+For example, the interface for entropy decoding (Huffman or arithmetic
+decoding) might look like this:
+
+	struct function_ptr_struct {
+		...
+		/* Entropy decoding methods */
+		void (*prepare_for_scan) ();
+		void (*get_next_mcu) ();
+		...
+		};
+
+	typedef struct function_ptr_struct * function_ptrs;
+
+The struct pointer is what will actually be passed around.  A call site might
+look like this:
+
+	some_function (function_ptrs fptrs)
+	    {
+		...
+		(*fptrs->get_next_mcu) (...);
+		...
+	    }
+
+(It might be worth inventing some specialized macros to hide the rather ugly
+syntax for method definition and call.)  Note that the caller doesn't know how
+many different get_next_mcu procedures there are, what their real names are,
+nor how to choose which one to call.
+
+An important benefit of this scheme is that it is easy to provide multiple
+versions of any method, each tuned to a particular case.  While a lot of
+precalculation might be done to select an optimal implementation of a method,
+the cost per invocation is constant.  For example, the MCU extraction step
+might have a "generic" method, plus one or more "hardwired" methods for the
+most popular sampling factors; the hardwired methods would be faster because
+they'd use straight-line code instead of for-loops.  The cost to determine
+which method to use is paid only once, at startup, and the selection criteria
+are hidden from the callers of the method.
+
+This plan differs a little bit from usual object-oriented structures, in that
+only one instance of each object class will exist during execution.  The
+reason for having the class structure is that on different runs we may create
+different instances (choose to execute different modules).
+
+To minimize the number of object pointers that have to be passed around, it
+will be easiest to have just a few big structs containing all the method
+pointers.  We'll actually use two such structs, one for "globally" defined
+methods (applicable to the whole file or to all components of the current
+scan) and one for methods applicable to a single component.  There'll be one
+copy of the second kind of struct for each component of the current scan.
+This is necessary so that preselection of an optimal method can be done based
+on component-specific information (like sampling ratios...)
+
+Because of this choice, it's best not to think of an "object" as a specific
+data structure.  Rather, an "object" is just a group of related methods.
+There would typically be one or more C modules (source files) providing
+concrete implementations of those methods.  You can think of the term
+"method" as denoting the common interface presented by some set of functions,
+and "object" as denoting a group of common method interfaces, or the total
+shared interface behavior of a group of modules.
+
+
+*** Data chunk sizes ***
+
+To make the cost of this object-oriented style really minimal, we should make
+sure that each method call does a fair amount of computation.  To do that we
+should pass large chunks of data around; for example, the colorspace
+conversion method should process much more than one pixel per call.
+
+For many steps, the most natural unit of data seems to be an "MCU row".
+This consists of one complete horizontal strip of the image, as high as an
+MCU.  In a noninterleaved scan, an MCU row is always eight samples high (when
+looking at samples) or one 8x8 block high (when looking at coefficients).  In
+an interleaved scan, an MCU row consists of all the data for one horizontal
+row of MCUs; this may be from one to four blocks high (eight to thirty-two
+samples) depending on the sampling factors.  The height and width of an MCU
+row may be different in each component.  (Note that the height and width of an
+MCU row changes at the subsampling and de-subsampling steps.  An unsubsampled
+image has the same size in each component.  The preceding statements apply to
+the subsampled dimensions.)
+
+For example, consider a 1024-pixel-wide image using (2h:2v)(1h:1v)(1h:1v)
+subsampling.  In the noninterleaved case, an MCU row of Y would contain 8x1024
+samples or the same number of frequency coefficients, so it would occupy
+8K bytes (samples) or 16K bytes (coefficients).  An MCU row of Cb or Cr would
+contain 8x512 samples and occupy half as much space.  In the interleaved case,
+an MCU row would contain 16x1024 Y samples, 8x512 Cb and 8x512 Cr samples, so
+a total of 24K (samples) or 48K (coefficients) would be needed.  This is a
+reasonable amount of data to expect to retain in memory at one time.  (Bear in
+mind that we'll usually need to have several MCU rows resident in memory at
+once, at the inputs and outputs to various pipeline steps.)
+
+The worst case is probably (2h:4v)(1h:1v)(1h:1v) interleaving (this uses 10
+blocks per MCU, which is the maximum allowed by the spec).  An MCU will then
+contain 32 sample rows worth of Y, so it would occupy 40K or 80K bytes for a
+1024-pixel-wide image.  The most memory-intensive step is probably cross-block
+smoothing, for which we'd need 3 MCU rows of coefficients as input and another
+one as output; that would be 320K of working storage.  Anything much larger
+would not fit in an 80x86 machine.  (To decompress wider pictures on an 80x86,
+we'll have to skip cross-block smoothing or else use temporary files.)
+
+This unit is thus a reasonable-sized chunk for passing through the pipeline.
+Of course, its major advantage is that it is a natural chunk size for the MCU
+assembly and disassembly steps to work with.
+
+For the entropy (Huffman or arithmetic) encoding/decoding steps, the most
+convenient chunk is a single MCU: one 8x8 block if not interleaved, three to
+ten such blocks if interleaved.  The advantage of this is that when handling
+interleaved data, the blocks have the same sequence of component membership on
+each call.  (For example, Y,Y,Y,Y,Cb,Cr when using (2h:2v)(1h:1v)(1h:1v)
+subsampling.)  The code needs to know component membership so that it can
+apply the right set of compression coefficients to each block.  A prebuilt
+array describing this membership can be used during each call.  This chunk
+size also makes it easy to handle restart intervals: just count off one MCU
+per call and reinitialize when the count reaches zero (restart intervals are
+specified in numbers of MCU).
+
+For similar reasons, one MCU is also the best chunk size for the frequency
+coefficient quantization and dequantization steps.
+
+For subsampling and desubsampling, the best chunk size is to have each call
+transform Vk sample rows from or to Vmax sample rows (Vk = this component's
+vertical sampling factor, Vmax = largest vertical sampling factor).  There are
+eight such chunks in each MCU row.  Using a whole MCU row as the chunk size
+would reduce function call overhead a fraction, but would imply more buffering
+to provide context for cross-pixel smoothing.
+
+
+*** Compression object structure ***
+
+I propose the following set of objects for the compressor.  Here an "object"
+is the common interface for one or more modules having comparable functions.
+
+Most of these objects can be justified as information-hiding modules.
+I've indicated what information is private to each object/module.
+
+Note that in all cases, the caller of a method is expected to have allocated
+any storage needed for it to return its result.  (Typically this storage can
+be re-used in successive calls, so malloc'ing and free'ing once per call is
+not reasonable.)  Also, much of the context required (compression parameters,
+image size, etc) will be passed around in large common data structures, which
+aren't described here; see the header files.  Notice that any object that
+might need to allocate working storage receives an "init" and a "term" call;
+"term" should be careful to free all allocated storage so that the JPEG system
+can be used multiple times during a program run.  (For the same reason,
+depending on static initialization of variables is a no-no.)
+
+1. Input file conversion to standardized form.  This provides these methods:
+	input_init: read the file header, report image size & component count.
+	get_input_row: read one pixel row, return it in our standard format.
+	input_term: finish up at the end.
+   In implementations that support multiple input formats, input_init could
+   set up an appropriate get_input_row method depending on the format it
+   finds.  Note that in most applications, the selection and opening of the
+   input file will be under the control of the user interface module; and
+   indeed the user interface may have already read the input header, so that
+   all that input_init may have to do is return previously saved values.  The
+   behind-the-scenes interaction between this object and the user interface is
+   not specified by this architecture.
+   (Hides format of input image and mechanism used to read it.  This code is
+   likely to vary considerably from one implementation to another.  Note that
+   the color space and number of color components of the source are not hidden;
+   but they are used only by the next object.)
+
+2. Gamma and color space conversion.  This provides three methods:
+	colorin_init: initialization.
+	get_sample_rows: read, convert, and return a specified number of pixel
+			 rows (not more than remain in the picture).
+	colorin_term: finish up at the end.
+   The most efficient approach seems to be for this object to call
+   get_input_row directly, rather than being passed the input data; that way,
+   any intermediate storage required can be local to this object.
+   (get_sample_rows might tell get_input_row to read directly into its own
+   output area and then convert in place; or it may do something different.
+   For example, conversion in place wouldn't work if it is changing the number
+   of color components.)  The output of this step is in the standardized
+   sample array format shown previously.
+   (Hides all knowledge of color space semantics and conversion.  Remaining
+   modules only need to know the number of JPEG components.)
+
+3. Edge expansion: needs only a single method.
+	edge_expand: Given an NxM sample array, expand to a desired size (a
+		     multiple of the MCU dimensions) by duplicating the last
+		     row or column.  Repeat for each component.
+   Expansion will occur in place, so the caller must have pre-allocated enough
+   storage.  (I'm assuming that it is easier and faster to do this expansion
+   than it is to worry about boundary conditions in the next two steps.
+   Notice that vertical expansion will occur only once, at the bottom of the
+   picture, so only horizontal expansion by a few pixels is speed-critical.)
+   (This doesn't really hide any information, so maybe it could be a simple
+   subroutine instead of a method.  Depends on whether we want to be able to
+   use alternative, optimized methods.)
+
+4. Subsampling: this will be applied to one component at a time.
+	subsample_init: initialize (precalculate convolution factors, for
+			example).  This will be called once per scan.
+	subsample: Given a sample array, reduce it to a smaller number of
+		   samples using specified sampling factors.
+	subsample_term: clean up at the end of a scan.
+   If the current component has vertical sampling factor Vk and the largest
+   sampling factor is Vmax, then the input is always Vmax sample rows (whose
+   width is a multiple of Hmax) and the output is always Vk sample rows.
+   Vmax additional rows above and below the nominal input rows are also passed
+   for use by partial-pixel-averaging sampling methods.  (Is this necessary?)
+   At the top and bottom of the image, these extra rows are copies of the
+   first or last actual input row.
+   (This hides whether and how cross-pixel averaging occurs.)
+
+5. MCU extraction (creation of a single sequence of 8x8 sample blocks).
+	extract_init: initialize as needed.  This will be called once per scan.
+	extract_MCUs: convert a sample array to a sequence of MCUs.
+	extract_term: clean up at the end of a scan.
+   Given one or more MCU rows worth of image data, extract sample blocks in the
+   appropriate order; pass these off to subsequent steps one MCU at a time.
+   The input must be a multiple of the MCU dimensions.  It will probably be
+   most convenient for the DCT transform, frequency quantization, and zigzag
+   reordering of each block to be done as simple subroutines of this step.
+   Once a transformed MCU has been completed, it'll be passed off to a
+   method call, which will be passed as a parameter to extract_MCUs.
+   That routine might either encode and output the MCU immediately, or buffer
+   it up for later output if we want to do global optimization of the entropy
+   encoding coefficients.  Note: when outputting a noninterleaved file this
+   object will be called separately for each component.  Direct output could
+   be done for the first component, but the others would have to be buffered.
+   (Again, an object mainly on the grounds that multiple instantiations might
+   be useful.)
+
+6. DCT transformation of each 8x8 block.  This probably doesn't have to be a
+   full-fledged method, but just a plain subroutine that will be called by MCU
+   extraction.  One 8x8 block will be processed per call.
+
+7. Quantization scaling and zigzag reordering of the elements in each 8x8
+   block.  (This can probably be a plain subroutine called once per block by
+   MCU extraction; hard to see a need for multiple instantiations here.)
+
+8. Entropy encoding (Huffman or arithmetic).
+	entropy_encoder_init: prepare for one scan.
+	entropy_encode: accepts an MCU's worth of quantized coefficients,
+			encodes and outputs them.
+	entropy_encoder_term: finish up at end of a scan (dump any buffered
+			      bytes, for example).
+   The data output by this module will be sent to the entropy_output method
+   provided by the pipeline controller.  (It will probably be worth using
+   buffering to pass multiple bytes per call of the output method.)  The
+   output method could be just write_jpeg_data, but might also be a dummy
+   routine that counts output bytes (for use during cut-and-try coefficient
+   optimization).
+   (This hides which entropy encoding method is in use.)
+
+9. JPEG file header construction.  This will provide these methods:
+	write_file_header: output the initial header.
+	write_scan_header: output scan header (called once per component
+			   if noninterleaved mode).
+	write_jpeg_data: the actual data output method for the preceding step.
+	write_scan_trailer: finish up after one scan.
+	write_file_trailer: finish up at end of file.
+   Note that compressed data is passed to the write_jpeg_data method, in case
+   a simple fwrite isn't appropriate for some reason.
+   (This hides which variant JPEG file format is being written.  Also, the
+   actual mechanism for writing the file is private to this object and the
+   user interface.)
+
+10. Pipeline control.  This object will provide the "main loop" that invokes
+    all the pipeline objects.  Note that we will need several different main
+    loops depending on the situation (interleaved output or not, global
+    optimization of encoding parameters or not, etc).  This object will do
+    most of the memory allocation, since it will provide the working buffers
+    that are the inputs and outputs of the pipeline steps.
+    (An object mostly to support multiple instantiations; however, overall
+    memory management and sequencing of operations are known only here.)
+
+11. Overall control.  This module will provide at least two routines:
+	jpeg_compress: the main entry point to the compressor.
+	per_scan_method_selection: called by pipeline controllers for
+				   secondary method selection passes.
+    jpeg_compress is invoked from the user interface after the UI has selected
+    the input and output files and obtained values for all compression
+    parameters that aren't dynamically determined.  jpeg_compress performs
+    basic initialization (e.g., calculating the size of MCUs), does the
+    "global" method selection pass, and finally calls the selected pipeline
+    control object.  (Per-scan method selections will be invoked by the
+    pipeline controller.)
+    Note that jpeg_compress can't be a method since it is invoked prior to
+    method selection.
+
+12. User interface; this is the architecture's term for "the rest of the
+    application program", i.e., that which invokes the JPEG compressor.  In a
+    standalone JPEG compression program the UI need be little more than a C
+    main() routine and argument parsing code; but we can expect that the JPEG
+    compressor may be incorporated into complex graphics applications, wherein
+    the UI is much more complex.  Much of the UI will need to be written
+    afresh for each non-Unix-like platform the compressor is ported to.
+    The UI is expected to supply input and output files and values for all
+    non-automatically-chosen compression parameters.  (Hence defaults are
+    determined by the UI; we should probably provide helpful routines to fill
+    in recommended defaults.)  The UI must also supply error handling
+    routines and some mechanism for trace messages.
+    (This module hides the user interface provided --- command line,
+    interactive, etc.  Except for error/message handling, the UI calls the
+    portable JPEG code, not the other way around.)
+
+13. (Optional) Compression parameter selection control.
+	entropy_optimize: given an array of MCUs ready to be fed to entropy
+			  encoding, find optimal encoding parameters.
+    The actual optimization algorithm ought to be separated out as an object,
+    even though a special pipeline control method will be needed.  (The
+    pipeline controller only has to understand that the output of extract_MCUs
+    must be built up as a virtual array rather than fed directly to entropy
+    encoding and output.  This pipeline behavior may also be useful for future
+    implementation of hierarchical modes, etc.)
+    To minimize the amount of control logic in the optimization module, the
+    pipeline control doesn't actually hand over big-array pointers, but rather
+    an "iterator": a function which knows how to scan the stored image.
+    (This hides the details of the parameter optimization algorithm.)
+
+    The present design doesn't allow for multiple passes at earlier points
+    in the pipeline, but allowing that would only require providing some
+    new pipeline control methods; nothing else need change.
+
+14. A memory management object.  This will provide methods to allocate "small"
+    things and "big" things.  Small things have to fit in memory and you get
+    back direct pointers (this could be handled by direct calls to malloc, but
+    it's cleaner not to assume malloc is the right routine).  "Big" things
+    mean buffered images for multiple passes, noninterleaved output, etc.
+    In this case the memory management object will give you room for a few MCU
+    rows and you have to ask for access to the next few; dumping and reloading
+    in a temporary file will go on behind the scenes.  (All big objects are
+    image arrays containing either samples or coefficients, and will be
+    scanned top-to-bottom some number of times, so we can apply this access
+    model easily.)  On a platform with virtual memory, the memory manager can
+    treat small and big things alike: just malloc up enough virtual memory for
+    the whole image, and let the operating system worry about swapping the
+    image to disk.
+
+    Most of the actual calls on the memory manager will be made from pipeline
+    control objects; changing any data item from "small" to "big" status would
+    require a new pipeline control object, since it will contain the logic to
+    ask for a new chunk of a big thing.  Thus, one way in which pipeline
+    controllers will vary is in which structures they treat as big.
+
+    The memory manager will need to be told roughly how much space is going to
+    be requested overall, so that it can figure out how big a buffer is safe
+    to allocate for a "big" object.  (If it happens that you are dealing with
+    a small image, you'd like to decide to keep it all in memory!)  The most
+    flexible way of doing this is to divide allocation of "big" objects into
+    two steps.  First, there will be one or more "request" calls that indicate
+    the desired object sizes; then an "instantiate" call causes the memory
+    manager to actually construct the objects.  The instantiation must occur
+    before the contents of any big object can be accessed.
+
+    For 80x86 CPUs, we would like the code to be compilable under small or
+    medium model, meaning that pointers are 16 bits unless explicitly declared
+    FAR.  Hence space allocated by the "small" allocator must fit into the
+    64Kb default data segment, along with stack space and global/static data.
+    For normal JPEG operations we seem to need only about 32Kb of such space,
+    so we are within the target (and have a reasonable slop for the needs of
+    a surrounding application program).  However, some color quantization
+    algorithms need 64Kb or more of all-in-memory space in order to create
+    color histograms.  For this purpose, we will also support "medium" size
+    things.  These are semantically the same as "small" things but are
+    referenced through FAR pointers.
+
+    The following methods will be needed:
+	alloc_small:	allocate an object of given size; use for any random
+			data that's not an image array.
+	free_small:	release same.
+	alloc_medium:	like alloc_small, but returns a FAR pointer.
+	free_medium:	release same.
+	alloc_small_sarray: construct an all-in-memory image sample array.
+	free_small_sarray:  release same.
+	alloc_small_barray,
+	free_small_barray:  ditto for block (coefficient) arrays.
+	request_big_sarray:  request a virtual image sample array.  The size
+			     of the in-memory buffer will be determined by the
+			     memory manager, but it will always be a multiple
+			     of the passed-in MCU height.
+	request_big_barray:  ditto for block (coefficient) arrays.
+	alloc_big_arrays:  instantiate all the big arrays previously requested.
+			   This call will also pass some info about future
+			   memory demands, so that the memory manager can
+			   figure out how much space to leave unallocated.
+	access_big_sarray: obtain access to a specified portion of a virtual
+			   image sample array.
+	access_big_barray: ditto for block (coefficient) arrays.
+	free_big_sarray:   release a virtual sample array.
+	free_big_barray:   ditto for block (coefficient) arrays.
+
+    alloc_big_arrays will be called by the pipeline controller, which does
+    most of the memory allocation anyway.  The only reason for having separate
+    request calls is to allow some of the other modules to get big arrays.
+    The pipeline controller is required to give an upper bound on total future
+    small-array requests, so that this space can be discounted.  (A fairly
+    conservative estimate will be adequate.)  Future small-object requests
+    aren't counted; the memory manager has to use a slop factor for those.
+    10K or so seems to be sufficient.  (In an 80x86, small objects aren't an
+    issue anyway, since they don't compete for far-heap space.  "Medium"-size
+    objects will have to be counted separately.)
+
+    The distinction between sample and coefficient array routines is annoying,
+    but it has to be maintained for machines in which "char *" is represented
+    differently from "int *"... on byte-addressable machines some of these
+    methods could point to the same code.
+
+    The array routines will operate on only 2-D arrays (one component at a
+    time), since different components may require different-size arrays.
+
+    (This object hides the knowledge of whether virtual memory is available,
+    as well as the actual interface to OS and library support routines.)
+
+Note that any given implementation will presumably contain only one
+instantiation of input file header reading, overall control, user interface,
+and memory management.  Thus these could be called as simple subroutines,
+without bothering with an object indirection.  This is essential for overall
+control (which has to initialize the object structure); I'm undecided whether
+to impose objectness on the other three.
+
+
+*** Decompression object structure ***
+
+I propose the following set of objects for decompression.  The general
+comments at the top of the compression object section also apply here.
+
+1. JPEG file scanning.  This will provide these methods:
+	read_file_header: read the file header, determine which variant
+			  JPEG format is in use, read everything through SOF.
+	read_scan_header: read scan header (up through SOS).  This is called
+			  after read_file_header and again after each scan;
+			  it returns TRUE if it finds SOS, FALSE if EOI.
+	read_jpeg_data: fetch data for entropy decoder.
+	read_scan_trailer: finish up after one scan, prepare for another call
+			   of read_scan_header (may be a no-op).
+	read_file_trailer: finish up at end of file (probably a no-op).
+   The entropy decoder must deal with restart markers, but all other JPEG
+   marker types will be handled in this object; useful data from the markers
+   will be extracted into data structures available to subsequent routines.
+   Note that on exit from read_file_header, only the SOF-marker data should be
+   assumed valid (image size, component IDs, sampling factors); other data
+   such as Huffman tables may not appear until after the SOF.  The overall
+   image size and colorspace can be determined after read_file_header, but not
+   whether or how the data is interleaved.  (This hides which variant JPEG
+   file format is being read.  In particular, for JPEG-in-TIFF the read_header
+   routines might not be scanning standard JPEG markers at all; they could
+   extract the data from TIFF tags.  The user interface will already have
+   opened the input file and possibly read part of the header before
+   read_file_header is called.)
+
+   NOTE: for JFIF/raw-JPEG file format, the read_jpeg_data routine is actually
+   supplied by the user interface; the jrdjfif module uses read_jpeg_data
+   internally to scan the input stream.  This makes it possible for the user
+   interface module to single-handedly implement special applications like
+   reading from a non-stdio source.  For JPEG-in-TIFF format, the need for
+   random access will make it impossible for this to work; hence the TIFF
+   header module will probably override the UI read_jpeg_data routine.
+   Non-stdio input from a TIFF file will require extensive surgery to the TIFF
+   header module, if indeed it is practical at all.
+
+2. Entropy (Huffman or arithmetic) decoding of the coefficient sequence.
+	entropy_decoder_init: prepare for one scan.
+	entropy_decode: decodes and returns an MCU's worth of quantized
+			coefficients per call.
+	entropy_decoder_term: finish up after a scan (may be a no-op).
+   This will read raw data by calling the read_jpeg_data method (I don't see
+   any reason to provide a further level of indirection).
+   (This hides which entropy encoding method is in use.)
+
+3. Quantization descaling and zigzag reordering of the elements in each 8x8
+   block.  (This can probably be a plain subroutine called once per block;
+   hard to see a need for multiple instantiations here.)
+
+4. MCU disassembly (conversion of a possibly interleaved sequence of 8x8
+   blocks back to separate components in pixel map order).
+	disassemble_init: initialize.  This will be called once per scan.
+	disassemble_MCU:  Given an MCU's worth of dequantized blocks,
+			  distribute them into the proper locations in a
+			  coefficient image array.
+	disassemble_term: clean up at the end of a scan.
+   Probably this should be called once per MCU row and should call the
+   preceding two objects repeatedly to obtain the row's data.  The output is
+   always a multiple of an MCU's dimensions.
+   (An object on the grounds that multiple instantiations might be useful.)
+
+5. Cross-block smoothing per JPEG section 13.10 or a similar algorithm.
+	smooth_coefficients: Given three block rows' worth of a single
+			     component, emit a smoothed equivalent of the
+			     middle row.  The "above" and "below" pointers
+			     may be NULL if at top/bottom of image.
+   The pipeline controller will do the necessary buffering to provide the
+   above/below context.  Smoothing will be optional since a good deal of
+   extra memory is needed to buffer the additional block rows.
+   (This object hides the details of the smoothing algorithm.)
+
+6. Inverse DCT transformation of each 8x8 block.  (This can be a plain
+   subroutine processing one block per call.)
+
+7. De-subsampling and smoothing: this will be applied to one component at a
+   time.  Note that cross-pixel smoothing, which was a separate step in the
+   prototype code, will now be performed simultaneously with expansion.
+	unsubsample_init: initialize (precalculate convolution factors, for
+			  example).  This will be called once per scan.
+	unsubsample: Given a sample array, enlarge it by specified sampling
+		     factors.
+	unsubsample_term: clean up at the end of a scan.
+   If the current component has vertical sampling factor Vk and the largest
+   sampling factor is Vmax, then the input is always Vk sample rows (whose
+   width is a multiple of Hk) and the output is always Vmax sample rows.
+   Vk additional rows above and below the nominal input rows are also passed
+   for use in cross-pixel smoothing.  At the top and bottom of the image,
+   these extra rows are copies of the first or last actual input row.
+   (This hides whether and how cross-pixel smoothing occurs.)
+
+8. Cropping to the original pixel dimensions (throwing away duplicated
+   pixels at the edges).  This won't be a separate object, just an
+   adjustment of the nominal image size in the pipeline controller.
+
+9. Color space reconversion and gamma adjustment.
+	colorout_init: initialization.  This will be passed the component
+		       data from read_file_header, and will determine the
+		       number of output components.
+	color_convert: convert a specified number of pixel rows.  Input and
+		       output are image arrays of same size but possibly
+		       different numbers of components.
+	colorout_term: cleanup (probably a no-op except for memory dealloc).
+   In practice will always be given an MCU row's worth of pixel rows, except
+   at the bottom where a smaller number of rows may be left over.  Note that
+   this object works on all the components at once.
+   (Hides all knowledge of color space semantics and conversion.  Remaining
+   modules only need to know the number of JPEG and output components.)
+
+10. Color quantization (used only if a colormapped output format is requested).
+    We use two different strategies depending on whether one-pass (on-the-fly)
+    or two-pass quantization is requested.  Note that the two-pass interface
+    is actually designed to let the quantizer make any number of passes.
+	color_quant_init: initialization, allocate working memory.  In 1-pass
+			  quantization, should call put_color_map.
+	color_quantize: convert a specified number of pixel rows.  Input
+			and output are image arrays of same size, but input
+			is N coefficients and output is only one.  (Used only
+			in 1-pass quantization.)
+	color_quant_prescan: prescan a specified number of pixel rows in
+			     2-pass quantization.
+	color_quant_doit: perform multi-pass color quantization.  Input is a
+			  "big" sample image, output is via put_color_map and
+			  put_pixel_rows.  (Used only in 2-pass quantization.)
+	color_quant_term: cleanup (probably a no-op except for memory dealloc).
+    For one-pass quantization the image is simply processed by color_quantize,
+    a few rows at a time.  For two-pass quantization, the pipeline controller
+    accumulates the output of color_convert into a "big" sample image.  The
+    color_quant_prescan method is invoked during this process so that the
+    quantizer can accumulate statistics.  At the end of the image,
+    color_quant_doit is called; it must rescan the "big" image and pass
+    converted data to the output module.  Additional scans of the image could
+    be made before the output pass is done (in fact, prescan could be a no-op).
+    As with entropy parameter optimization, the pipeline controller actually
+    passes an iterator function rather than direct access to the big image.
+    NOTE: it might be better to do this on the internal color space instead of
+    RGB?  If so, it would need to be performed one step earlier.
+    (Hides color quantization algorithm.)
+
+11. Writing of the desired image format.
+	output_init: produce the file header given data from read_file_header.
+	put_color_map: output colormap, if any (called by color quantizer).
+	put_pixel_rows: output image data in desired format.
+	output_term: finish up at the end.
+    Note that whether colormapping is needed will be determined by the user
+    interface object prior to method selection.  In implementations that
+    support multiple output formats, the actual output format will also be
+    determined by the user interface.
+    (Hides format of output image and mechanism used to write it.  Note that
+    several other objects know the color model used by the output format.  The
+    actual mechanism for writing the file is private to this object and the
+    user interface.)
+
+12. Pipeline control.  This object will provide the "main loop" that invokes
+    all the pipeline objects.  Note that we will need several different main
+    loops depending on the situation (interleaved input or not, whether to
+    apply cross-block smoothing or not, etc).  We may want to divvy up the
+    pipeline controllers into two levels, one that retains control over the
+    whole file and one that is invoked per scan.
+    This object will do most of the memory allocation, since it will provide
+    the working buffers that are the inputs and outputs of the pipeline steps.
+    (An object mostly to support multiple instantiations; however, overall
+    memory management and sequencing of operations are known only here.)
+
+13. Overall control.  This module will provide at least two routines:
+	jpeg_decompress: the main entry point to the decompressor.
+	per_scan_method_selection: called by pipeline controllers for
+				   secondary method selection passes.
+    jpeg_decompress is invoked from the user interface after the UI has
+    selected the input and output files and obtained values for all
+    user-specified options (e.g., output file format, whether to do block
+    smoothing).  jpeg_decompress calls read_file_header, performs basic
+    initialization (e.g., calculating the size of MCUs), does the "global"
+    method selection pass, and finally calls the selected pipeline control
+    object.  (Per-scan method selections will be invoked by the pipeline
+    controller.)
+    Note that jpeg_decompress can't be a method since it is invoked prior to
+    method selection.
+
+14. User interface; this is the architecture's term for "the rest of the
+    application program", i.e., that which invokes the JPEG decompressor.
+    The UI is expected to supply input and output files and values for all
+    operational parameters.  The UI must also supply error handling routines.
+    At the moment I can't think of any nonfatal errors the JPEG code is likely
+    to report, so a single report-this-error-and-exit method should be
+    sufficient.
+    (This module hides the user interface provided --- command line,
+    interactive, etc.  Except for error handling, the UI calls the portable
+    JPEG code, not the other way around.)
+
+15. A memory management object.  This will be identical to the memory
+    management for compression (and will be the same code, in combined
+    programs).  See above for details.
+
+
+*** Initial method selection ***
+
+The main ugliness in this design is the portion of startup that will select
+which of several instantiations should be used for each of the objects.  (For
+example, Huffman or arithmetic for entropy encoding; one of several pipeline
+controllers depending on interleaving, the size of the image, etc.)  It's not
+really desirable to have a single chunk of code that knows the names of all
+the possible instantiations and the conditions under which to select each one.
+
+The best approach seems to be to provide a selector function for each object
+(group of related method calls).  This function knows about each possible
+instantiation of its object and how to choose the right one; but it doesn't
+know about any other objects.
+
+Note that there will be several rounds of method selection: at initial startup,
+after overall compression parameters are determined (after the file header is
+read, if decompressing), and one in preparation for each scan (this occurs
+more than once if the file is noninterleaved).  Each object method will need
+to be clearly identified as to which round sets it up.
+
+
+*** Implications of DNL marker ***
+
+Some JPEG files may use a DNL marker to postpone definition of the image
+height (this would be useful for a fax-like scanner's output, for instance).
+In these files the SOF marker claims the image height is 0, and you only
+find out the true image height at the end of the first scan.
+
+We could handle these files as follows:
+1. Upon seeing zero image height, replace it by 65535 (the maximum allowed).
+2. When the DNL is found, update the image height in the global image
+   descriptor.
+This implies that pipeline control objects must avoid making copies of the
+image height, and must re-test for termination after each MCU row.  This is
+no big deal.
+
+In situations where image-size data structures are allocated, this approach
+will result in very inefficient use of virtual memory or
+much-larger-than-necessary temporary files.  This seems acceptable for
+something that probably won't be a mainstream usage.  People might have to
+forgo use of memory-hogging options (such as two-pass color quantization or
+noninterleaved JPEG files) if they want efficient conversion of such files.
+(One could improve efficiency by demanding a user-supplied upper bound for the
+height, less than 65536; in most cases it could be much less.)
+
+Alternately, we could insist that DNL-using files be preprocessed by a
+separate program that reads ahead to the DNL, then goes back and fixes the SOF
+marker.  This is a much simpler solution and is probably far more efficient.
+Even if one wants piped input, buffering the first scan of the JPEG file
+needs a lot smaller temp file than is implied by the maximum-height method.
+For this approach we'd simply treat DNL as a no-op in the decompressor (at
+most, check that it matches the SOF image height).
+
+We will not worry about making the compressor capable of outputting DNL.  Note
+that something similar to the first scheme above could be applied if anyone
+ever wants to make that work.
+
+
+*** Notes for MS-DOS implementors ***
+
+The standalone cjpeg and djpeg applications can be compiled in "small" memory
+model, at least at the moment; as the code grows we may be forced to switch to
+"medium" model.  (Small = both code and data pointers are near by default;
+medium = far code pointers, near data pointers.)  Medium model will slow down
+calls through method pointers, but I don't think this will amount to any
+significant speed penalty.
+
+When integrating the JPEG code into a larger application, it's a good idea to
+stay with a small-data-space model if possible.  An 8K stack is much more than
+sufficient for the JPEG code, and its static data requirements are less than
+1K.  When executed, it will typically malloc about 10K worth of near heap
+space (and lots of far heap, but that doesn't count in this calculation).
+This figure will vary depending on image size and other factors, but figuring
+20K should be more than sufficient.  Thus you have about 35K available for
+other modules' static data and near heap requirements before you need to go to
+a larger memory model.  The C library's static data will account for several K
+of this, but that still leaves a good deal for your needs.  (If you are tight
+on space, you could reduce JPEG_BUF_SIZE from 4K to 1K to save 3K of near heap
+space.)
+
+As the code is improved, we will endeavor to hold the near data requirements
+to the range given above.  This does imply that certain data structures will
+be allocated as FAR although they would fit in near space if we assumed the
+JPEG code is stand-alone.  (The LZW tables in jrdgif/jwrgif are examples.)
+To make an optimal implementation, you might want to move these structures
+back to near heap if you know there is sufficient space.
+
+
+*** Potential optimizations ***
+
+For colormapped input formats it might be worthwhile to merge the input file
+reading and the colorspace conversion steps; in other words, do the colorspace
+conversion by hacking up the colormap before inputting the image body, rather
+than doing the conversion on each pixel independently.  Not clear if this is
+worth the uglification involved.  In the above design for the compressor, only
+the colorspace conversion step ever sees the output of get_input_row, so this
+sort of thing could be done via private agreement between those two modules.
+
+Level shift from 0..255 to -128..127 may be done either during colorspace
+conversion, or at the moment of converting an 8x8 sample block into the format
+used by the DCT step (which will be signed short or long int).  This could be
+selectable by a compile-time flag, so that the intermediate steps can work on
+either signed or unsigned chars as samples, whichever is most easily handled
+by the platform.  However, making sure that rounding is done right will be a
+lot easier if we can assume positive values.  At the moment I think that
+benefit is worth the overhead of "& 0xFF" when reading out sample values on
+signed-char-only machines.
diff --git a/codingrules b/codingrules
new file mode 100644
index 0000000..fd6f700
--- /dev/null
+++ b/codingrules
@@ -0,0 +1,99 @@
+
+	JPEG SYSTEM CODING RULES		27-SEP-91
+
+Since numerous people will be contributing code and bug fixes, it's important
+to establish a common coding style.  The goal of using similar coding styles
+is much more important than the details of just what that style is.
+
+I suggest we follow the recommendations of "Recommended C Style and Coding
+Standards" revision 6.1 (Cannon et al. as modified by Spencer, Keppel and
+Brader).  I have placed a copy of this document in the jpeg FTP archive (see
+jpeg/doc/cstyle.ms.tbl.Z, or cstyle.txt.Z for those without nroff/tbl).
+
+Unless someone has a real strong objection, let's do block comments thusly:
+
+/*
+ *  Block comments in this style.
+ */
+
+and indent statements in K&R style, e.g.,
+
+	if (test) {
+	    then-part;
+	} else {
+	    else-part;
+	}
+
+I suggest that multi-word names be written in the style multi_word_name
+rather than multiWordName, but I am open to argument on this.
+
+
+I would like to use function prototypes everywhere, and rely on automatic
+source code transformation to feed non-ANSI C compilers.  The best tool
+I have so far found for this is 'ansi2knr.c', which is part of Ghostscript.
+ansi2knr is not very bright, so it imposes a format requirement on function
+declarations: the function name MUST BEGIN IN COLUMN 1.  Thus all functions
+should be written in the following style:
+
+static int *
+function_name (int a, char *b)
+{
+    code...
+}
+
+ansi2knr won't help with method declarations (function pointers in structs).
+I suggest we use a macro to declare method pointers, something like this:
+
+#ifdef PROTO
+#define METHOD(type,methodname,arglist)  type (*methodname) arglist
+#else
+#define METHOD(type,methodname,arglist)  type (*methodname) ()
+#endif
+
+which is used like this:
+
+struct function_pointers {
+	METHOD(void, init_entropy_encoder, (functptrs fptrs, jparms *jp));
+	METHOD(void, term_entropy_encoder, (void));
+};
+
+Note the set of parentheses surrounding the parameter list.
+
+A similar solution is used for external function declarations (see the PP
+macro in jpegdata.h).
+
+If the code is to work on non-ANSI compilers, you cannot rely on a prototype
+declaration to coerce actual parameters into the right types.  Therefore, use
+explicit casts on actual parameters whenever the actual parameter type is not
+identical to the formal parameter.  Beware of implicit conversions to "int".
+
+It seems there are some non-ANSI compilers in which the sizeof() operator
+is defined to return int, while size_t is defined as long.  Needless to say,
+this is brain-damaged.  Always use the SIZEOF() macro in place of sizeof(),
+so that the result is guaranteed to be of type size_t.
+
+
+We can expect that the JPEG compressor and decompressor will be incorporated
+into larger programs.  Therefore, the following rules are important:
+
+1. Avoid direct use of any file I/O, "malloc", error report printouts, etc;
+pass these through the common routines provided.
+
+2. Assume that the JPEG code may be invoked more than once per program run;
+therefore, do not rely on static initialization of variables, and be careful
+to release all allocated storage at the end of processing.
+
+3. Minimize global namespace pollution.  Functions should be declared static
+wherever possible.  (Note that our method-based calling conventions help this
+a lot: in many modules only the method-selector function will ever need to be
+called directly, so only that function need be externally visible.)  All
+global function names should begin with "j", and should be unique in the first
+six characters for portability reasons.
+Don't use global variables at all; anything that must be used in another
+module should be put into parameters (there'll be some large structs passed
+around for this purpose).
+
+4. Source file names should also begin with "j"; remember to keep them to
+eight characters (plus ".c" or ".h", etc) to make life easy for MS-DOSers.
+Do not put code for both compression and decompression into the same source
+file.
diff --git a/egetopt.c b/egetopt.c
new file mode 100644
index 0000000..8183d35
--- /dev/null
+++ b/egetopt.c
@@ -0,0 +1,276 @@
+/*
+ * egetopt.c -- Extended 'getopt'.
+ *
+ * A while back, a public-domain version of getopt() was posted to the
+ * net.  A bit later, a gentleman by the name of Keith Bostic made some
+ * enhancements and reposted it.
+ *
+ * In recent weeks (i.e., early-to-mid 1988) there's been some
+ * heated discussion in comp.lang.c about the merits and drawbacks
+ * of getopt(), especially with regard to its handling of '?'.
+ *
+ * In light of this, I have taken Mr. Bostic's public-domain getopt()
+ * and have made some changes that I hope will be considered to be
+ * improvements.  I call this routine 'egetopt' ("Extended getopt").
+ * The default behavior of this routine is the same as that of getopt(),
+ * but it has some optional features that make it more useful.  These
+ * options are controlled by the settings of some global variables.
+ * By not setting any of these extra global variables, you will have
+ * the same functionality as getopt(), which should satisfy those
+ * purists who believe getopt() is perfect and can never be improved.
+ * If, on the other hand, you are someone who isn't satisfied with the
+ * status quo, egetopt() may very well give you the added capabilities
+ * you want.
+ *
+ * Look at the enclosed README file for a description of egetopt()'s
+ * new features.
+ *
+ * The code was originally posted to the net as getopt.c by ...
+ *
+ *	Keith Bostic
+ *	ARPA: keith@seismo 
+ *	UUCP: seismo!keith
+ *
+ * Current version: added enhancements and comments, reformatted code.
+ *
+ *	Lloyd Zusman
+ *	Master Byte Software
+ *	Los Gatos, California
+ *	Internet:	ljz@fx.com
+ *	UUCP:		...!ames!fxgrp!ljz
+ *
+ *    	May, 1988
+ */
+
+/*
+ * If you want, include stdio.h or something where EOF and NULL are defined.
+ * However, egetopt() is written so as not to need stdio.h, which should
+ * make it significantly smaller on some systems.
+ */
+
+#ifndef EOF
+# define EOF		(-1)
+#endif /* ! EOF */
+
+#ifndef NULL
+# define NULL		(char *)0
+#endif /* ! NULL */
+
+/*
+ * None of these constants are referenced in the executable portion of
+ * the code ... their sole purpose is to initialize global variables.
+ */
+#define BADCH		(int)'?'
+#define NEEDSEP		(int)':'
+#define MAYBESEP	(int)'\0'
+#define ERRFD		2
+#define EMSG		""
+#define START		"-"
+
+/*
+ * Here are all the pertinent global variables.
+ */
+int opterr = 1;		/* if true, output error message */
+int optind = 1;		/* index into parent argv vector */
+int optopt;		/* character checked for validity */
+int optbad = BADCH;	/* character returned on error */
+int optchar = 0;	/* character that begins returned option */
+int optneed = NEEDSEP;	/* flag for mandatory argument */
+int optmaybe = MAYBESEP;/* flag for optional argument */
+int opterrfd = ERRFD;	/* file descriptor for error text */
+char *optarg;		/* argument associated with option */
+char *optstart = START;	/* list of characters that start options */
+
+
+/*
+ * Macros.
+ */
+
+/*
+ * Conditionally print out an error message and return (depends on the
+ * setting of 'opterr' and 'opterrfd').  Note that this version of
+ * TELL() doesn't require the existence of stdio.h.
+ */
+#define TELL(S)	{ \
+	if (opterr && opterrfd >= 0) { \
+		char option = optopt; \
+		write(opterrfd, *nargv, strlen(*nargv)); \
+		write(opterrfd, (S), strlen(S)); \
+		write(opterrfd, &option, 1); \
+		write(opterrfd, "\n", 1); \
+	} \
+	return (optbad); \
+}
+
+/*
+ * This works similarly to index() and strchr().  I include it so that you
+ * don't need to be concerned as to which one your system has.
+ */
+static char *
+_sindex(string, ch)
+char *string;
+int ch;
+{
+	if (string != NULL) {
+		for (; *string != '\0'; ++string) {
+			if (*string == (char)ch) {
+				return (string);
+			}
+		}
+	}
+
+	return (NULL);
+}
+
+/*
+ * Here it is:
+ */
+int
+egetopt(nargc, nargv, ostr)
+int nargc;
+char **nargv;
+char *ostr;
+{
+	static char *place = EMSG;	/* option letter processing */
+	register char *oli;		/* option letter list index */
+	register char *osi = NULL;	/* option start list index */
+
+	if (nargv == (char **)NULL) {
+		return (EOF);
+	}
+
+	if (nargc <= optind || nargv[optind] == NULL) {
+		return (EOF);
+	}
+
+	if (place == NULL) {
+		place = EMSG;
+	}
+
+	/*
+	 * Update scanning pointer.
+	 */
+	if (*place == '\0') {
+		place = nargv[optind];
+		if (place == NULL) {
+			return (EOF);
+		}
+		osi = _sindex(optstart, *place);
+		if (osi != NULL) {
+			optchar = (int)*osi;
+		}
+		if (optind >= nargc || osi == NULL || *++place == '\0') {
+		    	return (EOF);
+		}
+
+		/*
+		 * Two adjacent, identical flag characters were found.
+		 * This takes care of "--", for example.
+		 */
+		if (*place == place[-1]) {
+			++optind;
+			return (EOF);
+		}
+	}
+
+	/*
+	 * If the option is a separator or the option isn't in the list,
+	 * we've got an error.
+	 */
+	optopt = (int)*place++;
+	oli = _sindex(ostr, optopt);
+	if (optopt == optneed || optopt == optmaybe || oli == NULL) {
+		/*
+		 * If we're at the end of the current argument, bump the
+		 * argument index.
+		 */
+		if (*place == '\0') {
+			++optind;
+		}
+		TELL(": illegal option -- ");	/* byebye */
+	}
+
+	/*
+	 * If there is no argument indicator, then we don't even try to
+	 * return an argument.
+	 */
+	++oli;
+	if (*oli == '\0' || (*oli != optneed && *oli != optmaybe)) {
+		/*
+		 * If we're at the end of the current argument, bump the
+		 * argument index.
+		 */
+		if (*place == '\0') {
+			++optind;
+		}
+		optarg = NULL;
+	}
+	/*
+	 * If we're here, there's an argument indicator.  It's handled
+	 * differently depending on whether it's a mandatory or an
+	 * optional argument.
+	 */
+	else {
+		/*
+		 * If there's no white space, use the rest of the
+		 * string as the argument.  In this case, it doesn't
+		 * matter if the argument is mandatory or optional.
+		 */
+		if (*place != '\0') {
+			optarg = place;
+		}
+		/*
+		 * If we're here, there's whitespace after the option.
+		 *
+		 * Is it a mandatory argument?  If so, return the
+		 * next command-line argument if there is one.
+		 */
+		else if (*oli == optneed) {
+			/*
+			 * If we're at the end of the argument list, there
+			 * isn't an argument and hence we have an error.
+			 * Otherwise, make 'optarg' point to the argument.
+			 */
+			if (nargc <= ++optind) {
+				place = EMSG;
+				TELL(": option requires an argument -- ");
+			}
+			else {
+				optarg = nargv[optind];
+			}
+		}
+		/*
+		 * If we're here it must have been an optional argument.
+		 */
+		else {
+			if (nargc <= ++optind) {
+				place = EMSG;
+				optarg = NULL;
+			}
+			else {
+				optarg = nargv[optind];
+				if (optarg == NULL) {
+					place = EMSG;
+				}
+				/*
+				 * If the next item begins with a flag
+				 * character, we treat it like a new
+				 * argument.  This is accomplished by
+				 * decrementing 'optind' and returning
+				 * a null argument.
+				 */
+				else if (_sindex(optstart, *optarg) != NULL) {
+					--optind;
+					optarg = NULL;
+				}
+			}
+		}
+		place = EMSG;
+		++optind;
+	}
+
+	/*
+	 * Return option letter.
+	 */
+	return (optopt);
+}
diff --git a/jbsmooth.c b/jbsmooth.c
new file mode 100644
index 0000000..ad2138d
--- /dev/null
+++ b/jbsmooth.c
@@ -0,0 +1,120 @@
+/*
+ * jbsmooth.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains cross-block smoothing routines.
+ * These routines are invoked via the smooth_coefficients method.
+ */
+
+#include "jinclude.h"
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+
+/*
+ * Cross-block coefficient smoothing.
+ */
+
+METHODDEF void
+smooth_coefficients (decompress_info_ptr cinfo,
+		     jpeg_component_info *compptr,
+		     JBLOCKROW above,
+		     JBLOCKROW currow,
+		     JBLOCKROW below,
+		     JBLOCKROW output)
+{
+  QUANT_TBL_PTR Qptr = cinfo->quant_tbl_ptrs[compptr->quant_tbl_no];
+  long blocks_in_row = compptr->subsampled_width / DCTSIZE;
+  long col;
+
+  /* First, copy the block row as-is.
+   * This takes care of the first & last blocks in the row, the top/bottom
+   * special cases, and the higher-order coefficients in each block.
+   */
+  jcopy_block_row(currow, output, blocks_in_row);
+
+  /* Now apply the smoothing calculation, but not to any blocks on the
+   * edges of the image.
+   */
+
+  if (above != NULL && below != NULL) {
+    for (col = 1; col < blocks_in_row-1; col++) {
+
+      /* See section 13.10 of JPEG-8-R8, or K.8 of JPEG-9-R6.
+       *
+       * As I understand it, this produces approximations
+       * for the low frequency AC components, based on the
+       * DC values of the block and its eight neighboring blocks.
+       * (Thus it can't be used for blocks on the image edges.)
+       */
+
+      /* The layout of these variables corresponds to
+       * the text in 13.10
+       */
+      
+      JCOEF DC1, DC2, DC3;
+      JCOEF DC4, DC5, DC6;
+      JCOEF DC7, DC8, DC9;
+      
+      long       AC01, AC02;
+      long AC10, AC11;
+      long AC20;
+      
+      DC1 = above [col-1][0];
+      DC2 = above [col  ][0];
+      DC3 = above [col+1][0];
+      DC4 = currow[col-1][0];
+      DC5 = currow[col  ][0];
+      DC6 = currow[col+1][0];
+      DC7 = below [col-1][0];
+      DC8 = below [col  ][0];
+      DC9 = below [col+1][0];
+      
+#define DIVIDE_256(x)	x = ( (x) < 0 ? -((128-(x))/256) : ((x)+128)/256 )
+      
+      AC01 = (36 * (DC4 - DC6));
+      DIVIDE_256(AC01);
+      AC10 = (36 * (DC2 - DC8));
+      DIVIDE_256(AC10);
+      AC20 = (9 * (DC2 + DC8 - 2*DC5));
+      DIVIDE_256(AC20);
+      AC11 = (5 * ((DC1 - DC3) - (DC7 - DC9)));
+      DIVIDE_256(AC11);
+      AC02 = (9 * (DC4 + DC6 - 2*DC5));
+      DIVIDE_256(AC02);
+      
+      /* I think that this checks to see if the quantisation
+       * on the transmitting side would have produced this
+       * answer. If so, then we use our (hopefully better)
+       * estimate.
+       */
+
+#define ABS(x)	((x) < 0 ? -(x) : (x))
+
+#define COND_ASSIGN(_ac,_n,_z)   if ((ABS(output[col][_n] - (_ac))<<1) <= Qptr[_z]) output[col][_n] = (_ac)
+
+      COND_ASSIGN(AC01,  1, 1);
+      COND_ASSIGN(AC02,  2, 5);
+      COND_ASSIGN(AC10,  8, 2);
+      COND_ASSIGN(AC11,  9, 4);
+      COND_ASSIGN(AC20, 16, 3);
+    }
+  }
+}
+
+
+/*
+ * The method selection routine for cross-block smoothing.
+ */
+
+GLOBAL void
+jselbsmooth (decompress_info_ptr cinfo)
+{
+  /* just one implementation for now */
+  cinfo->methods->smooth_coefficients = smooth_coefficients;
+}
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
diff --git a/jcarith.c b/jcarith.c
new file mode 100644
index 0000000..1949459
--- /dev/null
+++ b/jcarith.c
@@ -0,0 +1,42 @@
+/*
+ * jcarith.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains arithmetic entropy encoding routines.
+ * These routines are invoked via the methods entropy_encode,
+ * entropy_encoder_init/term, and entropy_optimize.
+ */
+
+#include "jinclude.h"
+
+#ifdef ARITH_CODING_SUPPORTED
+
+
+/*
+ * The arithmetic coding option of the JPEG standard specifies Q-coding,
+ * which is covered by patents held by IBM (and possibly AT&T and Mitsubishi).
+ * At this time it does not appear to be legal for the Independent JPEG
+ * Group to distribute software that implements arithmetic coding.
+ * We have therefore removed arithmetic coding support from the
+ * distributed source code.
+ *
+ * We're not happy about it either.
+ */
+
+
+/*
+ * The method selection routine for arithmetic entropy encoding.
+ */
+
+GLOBAL void
+jselcarithmetic (compress_info_ptr cinfo)
+{
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo->emethods, "Sorry, there are legal restrictions on arithmetic coding");
+  }
+}
+
+#endif /* ARITH_CODING_SUPPORTED */
diff --git a/jccolor.c b/jccolor.c
new file mode 100644
index 0000000..7fd198c
--- /dev/null
+++ b/jccolor.c
@@ -0,0 +1,203 @@
+/*
+ * jccolor.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input colorspace conversion routines.
+ * These routines are invoked via the methods get_sample_rows
+ * and colorin_init/term.
+ */
+
+#include "jinclude.h"
+
+
+static JSAMPARRAY pixel_row;	/* Workspace for a pixel row in input format */
+
+
+/*
+ * Initialize for colorspace conversion.
+ */
+
+METHODDEF void
+colorin_init (compress_info_ptr cinfo)
+{
+  /* Allocate a workspace for the result of get_input_row. */
+  pixel_row = (*cinfo->emethods->alloc_small_sarray)
+		(cinfo->image_width, (long) cinfo->input_components);
+}
+
+
+/*
+ * Fetch some rows of pixels from get_input_row and convert to the
+ * JPEG colorspace.
+ * This version handles RGB -> YCbCr conversion.
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ */
+
+METHODDEF void
+get_rgb_ycc_rows (compress_info_ptr cinfo,
+		  int rows_to_read, JSAMPIMAGE image_data)
+{
+  register INT32 r, g, b;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JSAMPROW outptr0, outptr1, outptr2;
+  register long col;
+  long width = cinfo->image_width;
+  int row;
+
+  for (row = 0; row < rows_to_read; row++) {
+    /* Read one row from the source file */
+    (*cinfo->methods->get_input_row) (cinfo, pixel_row);
+    /* Convert colorspace */
+    inptr0 = pixel_row[0];
+    inptr1 = pixel_row[1];
+    inptr2 = pixel_row[2];
+    outptr0 = image_data[0][row];
+    outptr1 = image_data[1][row];
+    outptr2 = image_data[2][row];
+    for (col = width; col > 0; col--) {
+      r = GETJSAMPLE(*inptr0++);
+      g = GETJSAMPLE(*inptr1++);
+      b = GETJSAMPLE(*inptr2++);
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; do not need an explicit range-limiting operation.
+       */
+      /* Y */
+      *outptr0++ = (   306*r +  601*g +  117*b + (INT32) 512) >> 10;
+      /* Cb */
+      *outptr1++ = ((-173)*r -  339*g +  512*b + (INT32) 512*(MAXJSAMPLE+1)) >> 10;
+      /* Cr */
+      *outptr2++ = (   512*r -  429*g -   83*b + (INT32) 512*(MAXJSAMPLE+1)) >> 10;
+    }
+  }
+}
+
+
+/*
+ * Fetch some rows of pixels from get_input_row and convert to the
+ * JPEG colorspace.
+ * This version handles grayscale (no conversion).
+ */
+
+METHODDEF void
+get_grayscale_rows (compress_info_ptr cinfo,
+		    int rows_to_read, JSAMPIMAGE image_data)
+{
+  int row;
+
+  for (row = 0; row < rows_to_read; row++) {
+    /* Read one row from the source file */
+    (*cinfo->methods->get_input_row) (cinfo, pixel_row);
+    /* Convert colorspace (gamma mapping needed here) */
+    jcopy_sample_rows(pixel_row, 0, image_data[0], row,
+		      1, cinfo->image_width);
+  }
+}
+
+
+/*
+ * Fetch some rows of pixels from get_input_row and convert to the
+ * JPEG colorspace.
+ * This version handles multi-component colorspaces without conversion.
+ */
+
+METHODDEF void
+get_noconvert_rows (compress_info_ptr cinfo,
+		    int rows_to_read, JSAMPIMAGE image_data)
+{
+  int row, ci;
+
+  for (row = 0; row < rows_to_read; row++) {
+    /* Read one row from the source file */
+    (*cinfo->methods->get_input_row) (cinfo, pixel_row);
+    /* Convert colorspace (gamma mapping needed here) */
+    for (ci = 0; ci < cinfo->input_components; ci++) {
+      jcopy_sample_rows(pixel_row, ci, image_data[ci], row,
+			1, cinfo->image_width);
+    }
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+colorin_term (compress_info_ptr cinfo)
+{
+  /* Release the workspace. */
+  (*cinfo->emethods->free_small_sarray)
+		(pixel_row, (long) cinfo->input_components);
+}
+
+
+/*
+ * The method selection routine for input colorspace conversion.
+ */
+
+GLOBAL void
+jselccolor (compress_info_ptr cinfo)
+{
+  /* Make sure input_components agrees with in_color_space */
+  switch (cinfo->in_color_space) {
+  case CS_GRAYSCALE:
+    if (cinfo->input_components != 1)
+      ERREXIT(cinfo->emethods, "Bogus input colorspace");
+    break;
+
+  case CS_RGB:
+    if (cinfo->input_components != 3)
+      ERREXIT(cinfo->emethods, "Bogus input colorspace");
+    break;
+
+  case CS_CMYK:
+    if (cinfo->input_components != 4)
+      ERREXIT(cinfo->emethods, "Bogus input colorspace");
+    break;
+
+  default:
+    ERREXIT(cinfo->emethods, "Unsupported input colorspace");
+    break;
+  }
+
+  /* Check num_components, set conversion method based on requested space */
+  switch (cinfo->jpeg_color_space) {
+  case CS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
+    if (cinfo->in_color_space == CS_GRAYSCALE)
+      cinfo->methods->get_sample_rows = get_grayscale_rows;
+    else
+      ERREXIT(cinfo->emethods, "Unsupported color conversion request");
+    break;
+
+  case CS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
+    if (cinfo->in_color_space == CS_RGB)
+      cinfo->methods->get_sample_rows = get_rgb_ycc_rows;
+    else
+      ERREXIT(cinfo->emethods, "Unsupported color conversion request");
+    break;
+
+  case CS_CMYK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
+    if (cinfo->in_color_space == CS_CMYK)
+      cinfo->methods->get_sample_rows = get_noconvert_rows;
+    else
+      ERREXIT(cinfo->emethods, "Unsupported color conversion request");
+    break;
+
+  default:
+    ERREXIT(cinfo->emethods, "Unsupported JPEG colorspace");
+    break;
+  }
+
+  cinfo->methods->colorin_init = colorin_init;
+  cinfo->methods->colorin_term = colorin_term;
+}
diff --git a/jcdeflts.c b/jcdeflts.c
new file mode 100644
index 0000000..cd1624a
--- /dev/null
+++ b/jcdeflts.c
@@ -0,0 +1,364 @@
+/*
+ * jcdeflts.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains optional default-setting code for the JPEG compressor.
+ */
+
+#include "jinclude.h"
+
+
+LOCAL void
+add_huff_table (compress_info_ptr cinfo,
+		HUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
+/* Define a Huffman table */
+{
+  if (*htblptr == NULL)
+    *htblptr = (*cinfo->emethods->alloc_small) (SIZEOF(HUFF_TBL));
+  
+  memcpy((void *) (*htblptr)->bits, (void *) bits,
+	 SIZEOF((*htblptr)->bits));
+  memcpy((void *) (*htblptr)->huffval, (void *) val,
+	 SIZEOF((*htblptr)->huffval));
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file.
+   * In an application where we are writing non-interchange JPEG files,
+   * it might be desirable to save space by leaving default Huffman tables
+   * out of the file.  To do that, just initialize sent_table = TRUE...
+   */
+
+  (*htblptr)->sent_table = FALSE;
+}
+
+
+LOCAL void
+std_huff_tables (compress_info_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG-8-R8 section 13.3) */
+{
+  static const UINT8 dc_luminance_bits[17] =
+    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
+  static const UINT8 dc_luminance_val[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 dc_chrominance_bits[17] =
+    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
+  static const UINT8 dc_chrominance_val[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 ac_luminance_bits[17] =
+    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
+  static const UINT8 ac_luminance_val[] =
+    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  static const UINT8 ac_chrominance_bits[17] =
+    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
+  static const UINT8 ac_chrominance_val[] =
+    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
+		 dc_luminance_bits, dc_luminance_val);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
+		 ac_luminance_bits, ac_luminance_val);
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
+		 dc_chrominance_bits, dc_chrominance_val);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
+		 ac_chrominance_bits, ac_chrominance_val);
+}
+
+
+/* This is the sample quantization table given in JPEG-8-R8 sec 13.1,
+ * but expressed in zigzag order (as are all of our quant. tables).
+ * The spec says that the values given produce "good" quality, and
+ * when divided by 2, "very good" quality.  (These two settings are
+ * selected by quality=50 and quality=75 in j_set_quality, below.)
+ */
+
+
+static const QUANT_VAL std_luminance_quant_tbl[DCTSIZE2] = {
+  16,  11,  12,  14,  12,  10,  16,  14,
+  13,  14,  18,  17,  16,  19,  24,  40,
+  26,  24,  22,  22,  24,  49,  35,  37,
+  29,  40,  58,  51,  61,  60,  57,  51,
+  56,  55,  64,  72,  92,  78,  64,  68,
+  87,  69,  55,  56,  80, 109,  81,  87,
+  95,  98, 103, 104, 103,  62,  77, 113,
+ 121, 112, 100, 120,  92, 101, 103,  99
+};
+
+static const QUANT_VAL std_chrominance_quant_tbl[DCTSIZE2] = {
+  17,  18,  18,  24,  21,  24,  47,  26,
+  26,  47,  99,  66,  56,  66,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99,
+  99,  99,  99,  99,  99,  99,  99,  99
+};
+
+
+LOCAL void
+add_quant_table (compress_info_ptr cinfo, int which_tbl,
+		 const QUANT_VAL *basic_table, int scale_factor,
+		 boolean force_baseline)
+/* Define a quantization table equal to the basic_table times */
+/* a scale factor (given as a percentage) */
+{
+  QUANT_TBL_PTR * qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
+  int i;
+  long temp;
+
+  if (*qtblptr == NULL)
+    *qtblptr = (*cinfo->emethods->alloc_small) (SIZEOF(QUANT_TBL));
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
+    /* limit the values to the valid range */
+    if (temp <= 0L) temp = 1L;
+#ifdef EIGHT_BIT_SAMPLES
+    if (temp > 32767L) temp = 32767L; /* QUANT_VALs are 'short' */
+#else
+    if (temp > 65535L) temp = 65535L; /* QUANT_VALs are 'UINT16' */
+#endif
+    if (force_baseline && temp > 255L)
+      temp = 255L;		/* limit to baseline range if requested */
+    (*qtblptr)[i] = (QUANT_VAL) temp;
+  }
+}
+
+
+GLOBAL void
+j_set_quality (compress_info_ptr cinfo, int quality, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting. */
+/* The 'quality' factor should be 0 (terrible) to 100 (very good). */
+/* Quality 50 corresponds to the JPEG basic tables given above; */
+/* quality 100 results in no quantization scaling at all. */
+/* If force_baseline is TRUE, quantization table entries are limited */
+/* to 0..255 for JPEG baseline compatibility; this is only an issue */
+/* for quality settings below 24. */
+{
+  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
+  if (quality <= 0) quality = 1;
+  if (quality > 100) quality = 100;
+
+  /* Convert quality rating to a percentage scaling of the basic tables.
+   * The basic table is used as-is (scaling 100) for a quality of 50.
+   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
+   * note that at Q=100 the scaling is 0, which will cause add_quant_table
+   * to make all the table entries 1 (hence, no quantization loss).
+   * Qualities 1..50 are converted to scaling percentage 5000/Q.
+   */
+  if (quality < 50)
+    quality = 5000 / quality;
+  else
+    quality = 200 - quality*2;
+
+  /* Set up two quantization tables using the specified quality scaling */
+  add_quant_table(cinfo, 0, std_luminance_quant_tbl, quality, force_baseline);
+  add_quant_table(cinfo, 1, std_chrominance_quant_tbl, quality, force_baseline);
+}
+
+
+
+/* Default parameter setup for compression.
+ *
+ * User interfaces that don't choose to use this routine must do their
+ * own setup of all these parameters.  Alternately, you can call this
+ * to establish defaults and then alter parameters selectively.
+ *
+ * See above for the meaning of the 'quality' parameter.  Typically,
+ * the application's default quality setting will be passed to this
+ * routine.  A later call on j_set_quality() can be used to change to
+ * a user-specified quality setting.
+ *
+ * This sets up for a color image; to output a grayscale image,
+ * do this first and call j_monochrome_default() afterwards.
+ * (The latter can be called within c_ui_method_selection, so the
+ * choice can depend on the input file header.)
+ * Note that if you want a JPEG colorspace other than GRAYSCALE or YCbCr,
+ * you should also change the component ID codes, and you should NOT emit
+ * a JFIF header (set write_JFIF_header = FALSE).
+ *
+ * CAUTION: if you want to compress multiple images per run, it's safest
+ * to call j_default_compression before *each* call to jpeg_compress (and
+ * j_free_defaults afterwards).  If this isn't practical, you'll have to
+ * be careful to reset any individual parameters that may change during
+ * the compression run.  The main thing you need to worry about as this
+ * is written is that the sent_table boolean in each Huffman table must
+ * be reset to FALSE before each compression; otherwise, Huffman tables
+ * won't get emitted for the second and subsequent images.
+ */
+
+GLOBAL void
+j_default_compression (compress_info_ptr cinfo, int quality)
+/* NB: the external methods must already be set up. */
+{
+  short i;
+  jpeg_component_info * compptr;
+
+  /* Initialize pointers as needed to mark stuff unallocated. */
+  cinfo->comp_info = NULL;
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  cinfo->data_precision = 8;	/* default; can be overridden by input_init */
+  cinfo->density_unit = 0;	/* Pixel size is unknown by default */
+  cinfo->X_density = 1;		/* Pixel aspect ratio is square by default */
+  cinfo->Y_density = 1;
+
+  cinfo->input_gamma = 1.0;	/* no gamma correction by default */
+
+  /* Prepare three color components; first is luminance which is also usable */
+  /* for grayscale.  The others are assumed to be UV or similar chrominance. */
+  cinfo->write_JFIF_header = TRUE;
+  cinfo->jpeg_color_space = CS_YCbCr;
+  cinfo->num_components = 3;
+  cinfo->comp_info = (*cinfo->emethods->alloc_small)
+			(4 * SIZEOF(jpeg_component_info));
+  /* Note: we allocate a 4-entry comp_info array so that user interface can
+   * easily change over to CMYK color space if desired.
+   */
+
+  compptr = &cinfo->comp_info[0];
+  compptr->component_index = 0;
+  compptr->component_id = 1;	/* JFIF specifies IDs 1,2,3 */
+  compptr->h_samp_factor = 2;	/* default to 2x2 subsamples of chrominance */
+  compptr->v_samp_factor = 2;
+  compptr->quant_tbl_no = 0;	/* use tables 0 for luminance */
+  compptr->dc_tbl_no = 0;
+  compptr->ac_tbl_no = 0;
+
+  compptr = &cinfo->comp_info[1];
+  compptr->component_index = 1;
+  compptr->component_id = 2;
+  compptr->h_samp_factor = 1;
+  compptr->v_samp_factor = 1;
+  compptr->quant_tbl_no = 1;	/* use tables 1 for chrominance */
+  compptr->dc_tbl_no = 1;
+  compptr->ac_tbl_no = 1;
+
+  compptr = &cinfo->comp_info[2];
+  compptr->component_index = 2;
+  compptr->component_id = 3;
+  compptr->h_samp_factor = 1;
+  compptr->v_samp_factor = 1;
+  compptr->quant_tbl_no = 1;	/* use tables 1 for chrominance */
+  compptr->dc_tbl_no = 1;
+  compptr->ac_tbl_no = 1;
+
+  /* Set up two quantization tables using the specified quality scaling */
+  /* Baseline compatibility is forced (a nonissue for reasonable defaults) */
+  j_set_quality(cinfo, quality, TRUE);
+
+  /* Set up two Huffman tables in case user interface wants Huffman coding */
+  std_huff_tables(cinfo);
+
+  /* Initialize default arithmetic coding conditioning */
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+
+  /* Use Huffman coding, not arithmetic coding, by default */
+  cinfo->arith_code = FALSE;
+
+  /* Color images are interleaved by default */
+  cinfo->interleave = TRUE;
+
+  /* By default, don't do extra passes to optimize entropy coding */
+  cinfo->optimize_coding = FALSE;
+
+  /* By default, use the simpler non-cosited sampling alignment */
+  cinfo->CCIR601_sampling = FALSE;
+
+  /* No restart markers */
+  cinfo->restart_interval = 0;
+}
+
+
+
+GLOBAL void
+j_monochrome_default (compress_info_ptr cinfo)
+/* Change the j_default_compression() values to emit a monochrome JPEG file. */
+{
+  jpeg_component_info * compptr;
+
+  cinfo->jpeg_color_space = CS_GRAYSCALE;
+  cinfo->num_components = 1;
+  /* Set single component to 1x1 subsampling */
+  compptr = &cinfo->comp_info[0];
+  compptr->h_samp_factor = 1;
+  compptr->v_samp_factor = 1;
+}
+
+
+
+/* This routine releases storage allocated by j_default_compression.
+ * Note that freeing the method pointer structs and the compress_info_struct
+ * itself are the responsibility of the user interface.
+ */
+
+GLOBAL void
+j_free_defaults (compress_info_ptr cinfo)
+{
+  short i;
+
+#define FREE(ptr)  if ((ptr) != NULL) \
+			(*cinfo->emethods->free_small) ((void *) ptr)
+
+  FREE(cinfo->comp_info);
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    FREE(cinfo->quant_tbl_ptrs[i]);
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    FREE(cinfo->dc_huff_tbl_ptrs[i]);
+    FREE(cinfo->ac_huff_tbl_ptrs[i]);
+  }
+}
diff --git a/jcexpand.c b/jcexpand.c
new file mode 100644
index 0000000..94878bd
--- /dev/null
+++ b/jcexpand.c
@@ -0,0 +1,75 @@
+/*
+ * jcexpand.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains image edge-expansion routines.
+ * These routines are invoked via the edge_expand method.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * Expand an image so that it is a multiple of the MCU dimensions.
+ * This is to be accomplished by duplicating the rightmost column
+ * and/or bottommost row of pixels.  The image has not yet been
+ * subsampled, so all components have the same dimensions.
+ */
+
+METHODDEF void
+edge_expand (compress_info_ptr cinfo,
+	     long input_cols, int input_rows,
+	     long output_cols, int output_rows,
+	     JSAMPIMAGE image_data)
+{
+  /* Expand horizontally */
+  if (input_cols < output_cols) {
+    register JSAMPROW ptr;
+    register JSAMPLE pixval;
+    register long count;
+    register int row;
+    short ci;
+    long numcols = output_cols - input_cols;
+
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      for (row = 0; row < input_rows; row++) {
+	ptr = image_data[ci][row] + (input_cols-1);
+	pixval = GETJSAMPLE(*ptr++);
+	for (count = numcols; count > 0; count--)
+	  *ptr++ = pixval;
+      }
+    }
+  }
+
+  /* Expand vertically */
+  /* This happens only once at the bottom of the image, */
+  /* so it needn't be super-efficient */
+  if (input_rows < output_rows) {
+    register int row;
+    short ci;
+    JSAMPARRAY this_component;
+
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      this_component = image_data[ci];
+      for (row = input_rows; row < output_rows; row++) {
+	jcopy_sample_rows(this_component, input_rows-1, this_component, row,
+			  1, output_cols);
+      }
+    }
+  }
+}
+
+
+/*
+ * The method selection routine for edge expansion.
+ */
+
+GLOBAL void
+jselexpand (compress_info_ptr cinfo)
+{
+  /* just one implementation for now */
+  cinfo->methods->edge_expand = edge_expand;
+}
diff --git a/jchuff.c b/jchuff.c
new file mode 100644
index 0000000..531bc75
--- /dev/null
+++ b/jchuff.c
@@ -0,0 +1,689 @@
+/*
+ * jchuff.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines.
+ * These routines are invoked via the methods entropy_encode,
+ * entropy_encoder_init/term, and entropy_optimize.
+ */
+
+#include "jinclude.h"
+
+
+/* Static variables to avoid passing 'round extra parameters */
+
+static compress_info_ptr cinfo;
+
+static INT32 huff_put_buffer;	/* current bit-accumulation buffer */
+static int huff_put_bits;	/* # of bits now in it */
+
+static char * output_buffer;	/* output buffer */
+static int bytes_in_buffer;
+
+
+
+LOCAL void
+fix_huff_tbl (HUFF_TBL * htbl)
+/* Compute derived values for a Huffman table */
+{
+  int p, i, l, lastp, si;
+  char huffsize[257];
+  UINT16 huffcode[257];
+  UINT16 code;
+  
+  /* Figure 7.3.5.4.2.1: make table of Huffman code length for each symbol */
+  /* Note that this is in code-length order. */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    for (i = 1; i <= htbl->bits[l]; i++)
+      huffsize[p++] = l;
+  }
+  huffsize[p] = 0;
+  lastp = p;
+  
+  /* Figure 7.3.5.4.2.2: generate the codes themselves */
+  /* Note that this is in code-length order. */
+  
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (huffsize[p] == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    code <<= 1;
+    si++;
+  }
+  
+  /* Figure 7.3.5.4.2.3: generate encoding tables */
+  /* These are code and size indexed by symbol value */
+
+  for (p = 0; p < lastp; p++) {
+    htbl->ehufco[htbl->huffval[p]] = huffcode[p];
+    htbl->ehufsi[htbl->huffval[p]] = huffsize[p];
+  }
+  
+  /* Figure 13.4.2.3.1: generate decoding tables */
+
+  p = 0;
+  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 */
+      p += htbl->bits[l];
+      htbl->maxcode[l] = huffcode[p-1];	/* maximum code of length l */
+    } else {
+      htbl->maxcode[l] = -1;
+    }
+  }
+}
+
+
+/* Outputting bytes to the file */
+
+LOCAL void
+flush_bytes (void)
+{
+  if (bytes_in_buffer)
+    (*cinfo->methods->entropy_output) (cinfo, output_buffer, bytes_in_buffer);
+  bytes_in_buffer = 0;
+}
+
+
+#define emit_byte(val)	((bytes_in_buffer >= JPEG_BUF_SIZE ? \
+				(flush_bytes(), 0) : 0), \
+			 output_buffer[bytes_in_buffer] = (val), \
+			 bytes_in_buffer++)
+
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of huff_put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in huff_put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+LOCAL void
+emit_bits (UINT16 code, int size)
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register INT32 put_buffer = code;
+  register int put_bits = huff_put_bits;
+
+  put_buffer &= (((INT32) 1) << size) - 1; /* Mask off any excess bits in code */
+  
+  put_bits += size;		/* new number of bits in buffer */
+  
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= huff_put_buffer; /* and merge with old buffer contents */
+  
+  while (put_bits >= 8) {
+    int c = (int) ((put_buffer >> 16) & 0xFF);
+    
+    emit_byte(c);
+    if (c == 0xFF) {		/* need to stuff a zero byte? */
+      emit_byte(0);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  huff_put_buffer = put_buffer;	/* Update global variables */
+  huff_put_bits = put_bits;
+}
+
+
+LOCAL void
+flush_bits (void)
+{
+  emit_bits((UINT16) 0x7F, 7);	/* fill any partial byte with ones */
+  huff_put_buffer = 0;		/* and reset bit-buffer to empty */
+  huff_put_bits = 0;
+}
+
+
+
+/* Encode a single block's worth of coefficients */
+/* Note that the DC coefficient has already been converted to a difference */
+
+LOCAL void
+encode_one_block (JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl)
+{
+  register INT32 temp;
+  register int nbits;
+  register int k, r, i;
+  
+  /* Encode the DC coefficient difference per section 7.3.5.1 */
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  temp = block[0];
+  if (temp < 0) temp = -temp;
+  
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+  
+  /* Emit the Huffman-coded symbol for the number of bits */
+  emit_bits(dctbl->ehufco[nbits], dctbl->ehufsi[nbits]);
+  
+  /* If positive, emit nbits low order bits; */
+  /* if negative, emit nbits low order bits of value-1 */
+  if ((temp = block[0]) < 0)
+    temp--;
+  
+  emit_bits((UINT16) temp, nbits);
+  
+  /* Encode the AC coefficients per section 7.3.5.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[k]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	emit_bits(actbl->ehufco[0xF0], actbl->ehufsi[0xF0]);
+	r -= 16;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      if (temp < 0) temp = -temp;
+
+      nbits = 1;		/* there must be at least one 1 bit */
+      while (temp >>= 1)
+	nbits++;
+      
+      /* Emit Huffman symbol for run length / number of bits */
+      i = (r << 4) + nbits;
+      emit_bits(actbl->ehufco[i], actbl->ehufsi[i]);
+      
+      /* If positive, emit nbits low order bits; */
+      /* if negative, emit nbits low order bits of value-1 */
+      if ((temp = block[k]) < 0)
+	temp--;
+      
+      emit_bits((UINT16) temp, nbits);
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    emit_bits(actbl->ehufco[0], actbl->ehufsi[0]);
+}
+
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ * This is invoked after writing the SOS marker.
+ * The pipeline controller must establish the entropy_output method pointer
+ * before calling this routine.
+ */
+
+METHODDEF void
+huff_init (compress_info_ptr xinfo)
+{
+  short ci;
+  jpeg_component_info * compptr;
+
+  /* Initialize static variables */
+  cinfo = xinfo;
+  huff_put_buffer = 0;
+  huff_put_bits = 0;
+
+  /* Initialize the output buffer */
+  output_buffer = (char *) (*cinfo->emethods->alloc_small)
+				((size_t) JPEG_BUF_SIZE);
+  bytes_in_buffer = 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;
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL void
+emit_restart (compress_info_ptr cinfo)
+{
+  short ci;
+
+  flush_bits();
+
+  emit_byte(0xFF);
+  emit_byte(RST0 + cinfo->next_restart_num);
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+    cinfo->last_dc_val[ci] = 0;
+
+  /* Update restart state */
+  cinfo->restarts_to_go = cinfo->restart_interval;
+  cinfo->next_restart_num++;
+  cinfo->next_restart_num &= 7;
+}
+
+
+/*
+ * Encode and output one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF void
+huff_encode (compress_info_ptr cinfo, JBLOCK *MCU_data)
+{
+  short blkn, ci;
+  jpeg_component_info * compptr;
+  JCOEF temp;
+
+  /* Account for restart interval, emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (cinfo->restarts_to_go == 0)
+      emit_restart(cinfo);
+    cinfo->restarts_to_go--;
+  }
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    /* Convert DC value to difference, update last_dc_val */
+    temp = MCU_data[blkn][0];
+    MCU_data[blkn][0] -= cinfo->last_dc_val[ci];
+    cinfo->last_dc_val[ci] = temp;
+    encode_one_block(MCU_data[blkn],
+		     cinfo->dc_huff_tbl_ptrs[compptr->dc_tbl_no],
+		     cinfo->ac_huff_tbl_ptrs[compptr->ac_tbl_no]);
+  }
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF void
+huff_term (compress_info_ptr cinfo)
+{
+  /* Flush out the last data */
+  flush_bits();
+  flush_bytes();
+  /* Release the I/O buffer */
+  (*cinfo->emethods->free_small) ((void *) output_buffer);
+}
+
+
+
+
+/*
+ * Huffman coding optimization.
+ *
+ * This actually is optimization, in the sense that we find the best possible
+ * Huffman table(s) for the given data.  We first scan the supplied data and
+ * count the number of uses of each symbol that is to be Huffman-coded.
+ * (This process must agree with the code above.)  Then we build an
+ * optimal Huffman coding tree for the observed counts.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+
+/* These are static so htest_one_block can find 'em */
+static long * dc_count_ptrs[NUM_HUFF_TBLS];
+static long * ac_count_ptrs[NUM_HUFF_TBLS];
+
+
+LOCAL void
+gen_huff_coding (compress_info_ptr cinfo, HUFF_TBL *htbl, long freq[])
+/* Generate the optimal coding for the given counts */
+{
+#define MAX_CLEN 32		/* assumed maximum initial code length */
+  UINT8 bits[MAX_CLEN+1];	/* bits[k] = # of symbols with code length k */
+  short codesize[257];		/* codesize[k] = code length of symbol k */
+  short others[257];		/* next symbol in current branch of tree */
+  int c1, c2;
+  int p, i, j;
+  long v;
+
+  /* This algorithm is explained in section 13.2 of JPEG-8-R8 */
+
+  MEMZERO((void *) bits, SIZEOF(bits));
+  MEMZERO((void *) codesize, SIZEOF(codesize));
+  for (i = 0; i < 257; i++)
+    others[i] = -1;		/* init links to empty */
+  
+  freq[256] = 1;		/* make sure there is a nonzero count */
+  /* including the pseudo-symbol 256 in the Huffman procedure guarantees
+   * that no real symbol is given code-value of all ones, because 256
+   * will be placed in the largest codeword category.
+   */
+
+  /* Huffman's basic algorithm to assign optimal code lengths to symbols */
+
+  for (;;) {
+    /* Find the smallest nonzero frequency, set c1 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c1 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v) {
+	v = freq[i];
+	c1 = i;
+      }
+    }
+
+    /* Find the next smallest nonzero frequency, set c2 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c2 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v && i != c1) {
+	v = freq[i];
+	c2 = i;
+      }
+    }
+
+    /* Done if we've merged everything into one frequency */
+    if (c2 < 0)
+      break;
+    
+    /* Else merge the two counts/trees */
+    freq[c1] += freq[c2];
+    freq[c2] = 0;
+
+    /* Increment the codesize of everything in c1's tree branch */
+    codesize[c1]++;
+    while (others[c1] >= 0) {
+      c1 = others[c1];
+      codesize[c1]++;
+    }
+    
+    others[c1] = c2;		/* chain c2 onto c1's tree branch */
+    
+    /* Increment the codesize of everything in c2's tree branch */
+    codesize[c2]++;
+    while (others[c2] >= 0) {
+      c2 = others[c2];
+      codesize[c2]++;
+    }
+  }
+
+  /* Now count the number of symbols of each code length */
+  for (i = 0; i <= 256; i++) {
+    if (codesize[i]) {
+      /* The JPEG standard seems to think that this can't happen, */
+      /* but I'm paranoid... */
+      if (codesize[i] > MAX_CLEN)
+	ERREXIT(cinfo->emethods, "Huffman code size table overflow");
+
+      bits[codesize[i]]++;
+    }
+  }
+
+  /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
+   * Huffman procedure assigned any such lengths, we must adjust the coding.
+   * Here is what the JPEG spec says about how this next bit works:
+   * Since symbols are paired for the longest Huffman code, the symbols are
+   * removed from this length category two at a time.  The prefix for the pair
+   * (which is one bit shorter) is allocated to one of the pair; then,
+   * skipping the BITS entry for that prefix length, a code word from the next
+   * shortest nonzero BITS entry is converted into a prefix for two code words
+   * one bit longer.
+   */
+  
+  for (i = MAX_CLEN; i > 16; i--) {
+    while (bits[i] > 0) {
+      j = i - 2;		/* find length of new prefix to be used */
+      while (bits[j] == 0)
+	j--;
+      
+      bits[i] -= 2;		/* remove two symbols */
+      bits[i-1]++;		/* one goes in this length */
+      bits[j+1] += 2;		/* two new symbols in this length */
+      bits[j]--;		/* symbol of this length is now a prefix */
+    }
+  }
+
+  /* Remove the count for the pseudo-symbol 256 from the largest codelength */
+  while (bits[i] == 0)		/* find largest codelength still in use */
+    i--;
+  bits[i]--;
+  
+  /* Return final symbol counts (only for lengths 0..16) */
+  memcpy((void *) htbl->bits, (void *) bits, SIZEOF(htbl->bits));
+  
+  /* Return a list of the symbols sorted by code length */
+  /* It's not real clear to me why we don't need to consider the codelength
+   * changes made above, but the JPEG spec seems to think this works.
+   */
+  p = 0;
+  for (i = 1; i <= MAX_CLEN; i++) {
+    for (j = 0; j <= 255; j++) {
+      if (codesize[j] == i) {
+	htbl->huffval[p] = j;
+	p++;
+      }
+    }
+  }
+}
+
+
+/* Process a single block's worth of coefficients */
+/* Note that the DC coefficient has already been converted to a difference */
+
+LOCAL void
+htest_one_block (JBLOCK block, JCOEF block0,
+		 long dc_counts[], long ac_counts[])
+{
+  register INT32 temp;
+  register int nbits;
+  register int k, r;
+  
+  /* Encode the DC coefficient difference per section 7.3.5.1 */
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  temp = block0;
+  if (temp < 0) temp = -temp;
+  
+  for (nbits = 0; temp; nbits++)
+    temp >>= 1;
+  
+  /* Count the Huffman symbol for the number of bits */
+  dc_counts[nbits]++;
+  
+  /* Encode the AC coefficients per section 7.3.5.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[k]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	ac_counts[0xF0]++;
+	r -= 16;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      if (temp < 0) temp = -temp;
+      
+      for (nbits = 0; temp; nbits++)
+	temp >>= 1;
+      
+      /* Count Huffman symbol for run length / number of bits */
+      ac_counts[(r << 4) + nbits]++;
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    ac_counts[0]++;
+}
+
+
+
+/*
+ * Trial-encode one MCU's worth of Huffman-compressed coefficients.
+ */
+
+LOCAL void
+htest_encode (compress_info_ptr cinfo, JBLOCK *MCU_data)
+{
+  short blkn, ci;
+  jpeg_component_info * compptr;
+
+  /* Take care of restart intervals if needed */
+  if (cinfo->restart_interval) {
+    if (cinfo->restarts_to_go == 0) {
+      /* Re-initialize DC predictions to 0 */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+	cinfo->last_dc_val[ci] = 0;
+      /* Update restart state */
+      cinfo->restarts_to_go = cinfo->restart_interval;
+    }
+    cinfo->restarts_to_go--;
+  }
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    /* NB: unlike the real entropy encoder, we may not change the input data */
+    htest_one_block(MCU_data[blkn],
+		    (JCOEF) (MCU_data[blkn][0] - cinfo->last_dc_val[ci]),
+		    dc_count_ptrs[compptr->dc_tbl_no],
+		    ac_count_ptrs[compptr->ac_tbl_no]);
+    cinfo->last_dc_val[ci] = MCU_data[blkn][0];
+  }
+}
+
+
+
+/*
+ * Find the best coding parameters for a Huffman-coded scan.
+ * When called, the scan data has already been converted to a sequence of
+ * MCU groups of quantized coefficients, which are stored in a "big" array.
+ * The source_method knows how to iterate through that array.
+ * On return, the MCU data is unmodified, but the Huffman tables referenced
+ * by the scan components may have been altered.
+ */
+
+METHODDEF void
+huff_optimize (compress_info_ptr cinfo, MCU_output_caller_ptr source_method)
+/* Optimize Huffman-coding parameters (Huffman symbol table) */
+{
+  int i, tbl;
+  HUFF_TBL **htblptr;
+
+  /* Allocate and zero the count tables */
+  /* Note that gen_huff_coding expects 257 entries in each table! */
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    dc_count_ptrs[i] = NULL;
+    ac_count_ptrs[i] = NULL;
+  }
+
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    /* Create DC table */
+    tbl = cinfo->cur_comp_info[i]->dc_tbl_no;
+    if (dc_count_ptrs[tbl] == NULL) {
+      dc_count_ptrs[tbl] = (long *) (*cinfo->emethods->alloc_small)
+					(257 * SIZEOF(long));
+      MEMZERO((void *) dc_count_ptrs[tbl], 257 * SIZEOF(long));
+    }
+    /* Create AC table */
+    tbl = cinfo->cur_comp_info[i]->ac_tbl_no;
+    if (ac_count_ptrs[tbl] == NULL) {
+      ac_count_ptrs[tbl] = (long *) (*cinfo->emethods->alloc_small)
+					(257 * SIZEOF(long));
+      MEMZERO((void *) ac_count_ptrs[tbl], 257 * SIZEOF(long));
+    }
+  }
+
+  /* Initialize DC predictions to 0 */
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    cinfo->last_dc_val[i] = 0;
+  }
+  /* Initialize restart stuff */
+  cinfo->restarts_to_go = cinfo->restart_interval;
+
+  /* Scan the MCU data, count symbol uses */
+  (*source_method) (cinfo, htest_encode);
+
+  /* Now generate optimal Huffman tables */
+  for (tbl = 0; tbl < NUM_HUFF_TBLS; tbl++) {
+    if (dc_count_ptrs[tbl] != NULL) {
+      htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
+      if (*htblptr == NULL)
+	*htblptr = (*cinfo->emethods->alloc_small) (SIZEOF(HUFF_TBL));
+      /* Set sent_table FALSE so updated table will be written to JPEG file. */
+      (*htblptr)->sent_table = FALSE;
+      /* Compute the optimal Huffman encoding */
+      gen_huff_coding(cinfo, *htblptr, dc_count_ptrs[tbl]);
+      /* Release the count table */
+      (*cinfo->emethods->free_small) ((void *) dc_count_ptrs[tbl]);
+    }
+    if (ac_count_ptrs[tbl] != NULL) {
+      htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
+      if (*htblptr == NULL)
+	*htblptr = (*cinfo->emethods->alloc_small) (SIZEOF(HUFF_TBL));
+      /* Set sent_table FALSE so updated table will be written to JPEG file. */
+      (*htblptr)->sent_table = FALSE;
+      /* Compute the optimal Huffman encoding */
+      gen_huff_coding(cinfo, *htblptr, ac_count_ptrs[tbl]);
+      /* Release the count table */
+      (*cinfo->emethods->free_small) ((void *) ac_count_ptrs[tbl]);
+    }
+  }
+}
+
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * The method selection routine for Huffman entropy encoding.
+ */
+
+GLOBAL void
+jselchuffman (compress_info_ptr cinfo)
+{
+  if (! cinfo->arith_code) {
+    cinfo->methods->entropy_encoder_init = huff_init;
+    cinfo->methods->entropy_encode = huff_encode;
+    cinfo->methods->entropy_encoder_term = huff_term;
+#ifdef ENTROPY_OPT_SUPPORTED
+    cinfo->methods->entropy_optimize = huff_optimize;
+#endif
+  }
+}
diff --git a/jcmain.c b/jcmain.c
new file mode 100644
index 0000000..f71d5ad
--- /dev/null
+++ b/jcmain.c
@@ -0,0 +1,272 @@
+/*
+ * jcmain.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a trivial test user interface for the JPEG compressor.
+ * It should work on any system with Unix- or MS-DOS-style command lines.
+ *
+ * Two different command line styles are permitted, depending on the
+ * compile-time switch TWO_FILE_COMMANDLINE:
+ *	cjpeg [options]  inputfile outputfile
+ *	cjpeg [options]  [inputfile]
+ * In the second style, output is always to standard output, which you'd
+ * normally redirect to a file or pipe to some other program.  Input is
+ * either from a named file or from standard input (typically redirected).
+ * The second style is convenient on Unix but is unhelpful on systems that
+ * don't support pipes.  Also, you MUST use the first style if your system
+ * doesn't do binary I/O to stdin/stdout.
+ */
+
+#include "jinclude.h"
+#ifdef __STDC__
+#include <stdlib.h>		/* to declare exit() */
+#endif
+
+#ifdef THINK_C
+#include <console.h>		/* command-line reader for Macintosh */
+#endif
+
+#ifdef DONT_USE_B_MODE		/* define mode parameters for fopen() */
+#define READ_BINARY	"r"
+#define WRITE_BINARY	"w"
+#else
+#define READ_BINARY	"rb"
+#define WRITE_BINARY	"wb"
+#endif
+
+
+/*
+ * If your system has getopt(3), you can use your library version by
+ * defining HAVE_GETOPT.  By default, we use the PD 'egetopt'.
+ */
+
+#ifdef HAVE_GETOPT
+extern int getopt PP((int argc, char **argv, char *optstring));
+extern char * optarg;
+extern int optind;
+#else
+#include "egetopt.c"
+#define getopt(argc,argv,opt)	egetopt(argc,argv,opt)
+#endif
+
+
+/*
+ * This routine determines what format the input file is,
+ * and selects the appropriate input-reading module.
+ *
+ * To determine which family of input formats the file belongs to,
+ * we look only at the first byte of the file, since C does not
+ * guarantee that more than one character can be pushed back with ungetc.
+ * This is sufficient for the currently envisioned set of input formats.
+ *
+ * If you need to look at more than one character to select an input module,
+ * you can either
+ *     1) assume you can fseek() the input file (may fail for piped input);
+ *     2) assume you can push back more than one character (works in
+ *        some C implementations, but unportable);
+ * or  3) don't put back the data, and modify the various input_init
+ *        methods to assume they start reading after the start of file.
+ */
+
+LOCAL void
+select_file_type (compress_info_ptr cinfo)
+{
+  int c;
+
+  if ((c = getc(cinfo->input_file)) == EOF)
+    ERREXIT(cinfo->emethods, "Empty input file");
+
+  switch (c) {
+#ifdef GIF_SUPPORTED
+  case 'G':
+    jselrgif(cinfo);
+    break;
+#endif
+#ifdef PPM_SUPPORTED
+  case 'P':
+    jselrppm(cinfo);
+    break;
+#endif
+  default:
+    ERREXIT(cinfo->emethods, "Unsupported input file format");
+    break;
+  }
+
+  if (ungetc(c, cinfo->input_file) == EOF)
+    ERREXIT(cinfo->emethods, "ungetc failed");
+}
+
+
+/*
+ * This routine gets control after the input file header has been read.
+ * It must determine what output JPEG file format is to be written,
+ * and make any other compression parameter changes that are desirable.
+ */
+
+METHODDEF void
+c_ui_method_selection (compress_info_ptr cinfo)
+{
+  /* If the input is gray scale, generate a monochrome JPEG file. */
+  if (cinfo->in_color_space == CS_GRAYSCALE)
+    j_monochrome_default(cinfo);
+  /* For now, always select JFIF output format. */
+#ifdef JFIF_SUPPORTED
+  jselwjfif(cinfo);
+#else
+  You shoulda defined JFIF_SUPPORTED.   /* deliberate syntax error */
+#endif
+}
+
+
+LOCAL void
+usage (char * progname)
+/* complain about bad command line */
+{
+  fprintf(stderr, "usage: %s ", progname);
+  fprintf(stderr, "[-I] [-Q quality 0..100] [-a] [-o] [-d]");
+#ifdef TWO_FILE_COMMANDLINE
+  fprintf(stderr, " inputfile outputfile\n");
+#else
+  fprintf(stderr, " [inputfile]\n");
+#endif
+  exit(2);
+}
+
+
+/*
+ * The main program.
+ */
+
+GLOBAL void
+main (int argc, char **argv)
+{
+  struct compress_info_struct cinfo;
+  struct compress_methods_struct c_methods;
+  struct external_methods_struct e_methods;
+  int c;
+
+  /* On Mac, fetch a command line. */
+#ifdef THINK_C
+  argc = ccommand(&argv);
+#endif
+
+  /* Initialize the system-dependent method pointers. */
+  cinfo.methods = &c_methods;
+  cinfo.emethods = &e_methods;
+  jselerror(&e_methods);	/* error/trace message routines */
+  jselvirtmem(&e_methods);	/* memory allocation routines */
+  c_methods.c_ui_method_selection = c_ui_method_selection;
+
+  /* Set up default input and output file references. */
+  /* (These may be overridden below.) */
+  cinfo.input_file = stdin;
+  cinfo.output_file = stdout;
+
+  /* Set up default parameters. */
+  e_methods.trace_level = 0;
+  j_default_compression(&cinfo, 75); /* default quality level */
+
+  /* Scan parameters */
+  
+  while ((c = getopt(argc, argv, "IQ:aod")) != EOF)
+    switch (c) {
+    case 'I':			/* Create noninterleaved file. */
+#ifdef MULTISCAN_FILES_SUPPORTED
+      cinfo.interleave = FALSE;
+#else
+      fprintf(stderr, "%s: sorry, multiple-scan support was not compiled\n",
+	      argv[0]);
+      exit(2);
+#endif
+      break;
+    case 'Q':			/* Quality factor. */
+      { int val;
+	if (optarg == NULL)
+	  usage(argv[0]);
+	if (sscanf(optarg, "%d", &val) != 1)
+	  usage(argv[0]);
+	/* Note: for now, we leave force_baseline FALSE.
+	 * In a production user interface, probably should make it TRUE
+	 * unless overridden by a separate switch.
+	 */
+	j_set_quality(&cinfo, val, FALSE);
+      }
+      break;
+    case 'a':			/* Use arithmetic coding. */
+#ifdef ARITH_CODING_SUPPORTED
+      cinfo.arith_code = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
+	      argv[0]);
+      exit(2);
+#endif
+      break;
+    case 'o':			/* Enable entropy parm optimization. */
+#ifdef ENTROPY_OPT_SUPPORTED
+      cinfo.optimize_coding = TRUE;
+#else
+      fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
+	      argv[0]);
+      exit(2);
+#endif
+      break;
+    case 'd':			/* Debugging. */
+      e_methods.trace_level++;
+      break;
+    case '?':
+    default:
+      usage(argv[0]);
+      break;
+    }
+
+  /* Select the input and output files */
+
+#ifdef TWO_FILE_COMMANDLINE
+
+  if (optind != argc-2) {
+    fprintf(stderr, "%s: must name one input and one output file\n", argv[0]);
+    usage(argv[0]);
+  }
+  if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
+    fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
+    exit(2);
+  }
+  if ((cinfo.output_file = fopen(argv[optind+1], WRITE_BINARY)) == NULL) {
+    fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind+1]);
+    exit(2);
+  }
+
+#else /* not TWO_FILE_COMMANDLINE -- use Unix style */
+
+  if (optind < argc-1) {
+    fprintf(stderr, "%s: only one input file\n", argv[0]);
+    usage(argv[0]);
+  }
+  if (optind < argc) {
+    if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
+      exit(2);
+    }
+  }
+
+#endif /* TWO_FILE_COMMANDLINE */
+
+  /* Figure out the input file format, and set up to read it. */
+  select_file_type(&cinfo);
+
+  /* Do it to it! */
+  jpeg_compress(&cinfo);
+
+  /* Release memory. */
+  j_free_defaults(&cinfo);
+#ifdef MEM_STATS
+  if (e_methods.trace_level > 0)
+    j_mem_stats();
+#endif
+
+  /* All done. */
+  exit(0);
+}
diff --git a/jcmaster.c b/jcmaster.c
new file mode 100644
index 0000000..b15217a
--- /dev/null
+++ b/jcmaster.c
@@ -0,0 +1,127 @@
+/*
+ * jcmaster.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main control for the JPEG compressor.
+ * The system-dependent (user interface) code should call jpeg_compress()
+ * after doing appropriate setup of the compress_info_struct parameter.
+ */
+
+#include "jinclude.h"
+
+
+METHODDEF void
+c_per_scan_method_selection (compress_info_ptr cinfo)
+/* Central point for per-scan method selection */
+{
+  /* Edge expansion */
+  jselexpand(cinfo);
+  /* Subsampling of pixels */
+  jselsubsample(cinfo);
+  /* MCU extraction */
+  jselcmcu(cinfo);
+}
+
+
+LOCAL void
+c_initial_method_selection (compress_info_ptr cinfo)
+/* Central point for initial method selection */
+{
+  /* Input image reading method selection is already done. */
+  /* So is output file header formatting (both are done by user interface). */
+
+  /* Gamma and color space conversion */
+  jselccolor(cinfo);
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+#ifdef ARITH_CODING_SUPPORTED
+  jselcarithmetic(cinfo);
+#else
+  cinfo->arith_code = FALSE;	/* force Huffman mode */
+#endif
+  jselchuffman(cinfo);
+  /* Pipeline control */
+  jselcpipeline(cinfo);
+  /* Overall control (that's me!) */
+  cinfo->methods->c_per_scan_method_selection = c_per_scan_method_selection;
+}
+
+
+LOCAL void
+initial_setup (compress_info_ptr cinfo)
+/* Do computations that are needed before initial method selection */
+{
+  short ci;
+  jpeg_component_info *compptr;
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    compptr = &cinfo->comp_info[ci];
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo->emethods, "Bogus sampling factors");
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+
+  }
+
+  /* Compute logical subsampled dimensions of components */
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    compptr = &cinfo->comp_info[ci];
+    compptr->true_comp_width = (cinfo->image_width * compptr->h_samp_factor
+				+ cinfo->max_h_samp_factor - 1)
+				/ cinfo->max_h_samp_factor;
+    compptr->true_comp_height = (cinfo->image_height * compptr->v_samp_factor
+				 + cinfo->max_v_samp_factor - 1)
+				 / cinfo->max_v_samp_factor;
+  }
+}
+
+
+/*
+ * This is the main entry point to the JPEG compressor.
+ */
+
+
+GLOBAL void
+jpeg_compress (compress_info_ptr cinfo)
+{
+  /* Read the input file header: determine image size & component count.
+   * NOTE: the user interface must have initialized the input_init method
+   * pointer (eg, by calling jselrppm) before calling me.
+   * The other file reading methods (get_input_row etc.) were probably
+   * set at the same time, but could be set up by input_init itself,
+   * or by c_ui_method_selection.
+   */
+  (*cinfo->methods->input_init) (cinfo);
+
+  /* Give UI a chance to adjust compression parameters and select */
+  /* output file format based on results of input_init. */
+  (*cinfo->methods->c_ui_method_selection) (cinfo);
+
+  /* Now select methods for compression steps. */
+  initial_setup(cinfo);
+  c_initial_method_selection(cinfo);
+
+  /* Initialize the output file & other modules as needed */
+  /* (entropy_encoder is inited by pipeline controller) */
+
+  (*cinfo->methods->colorin_init) (cinfo);
+  (*cinfo->methods->write_file_header) (cinfo);
+
+  /* And let the pipeline controller do the rest. */
+  (*cinfo->methods->c_pipeline_controller) (cinfo);
+
+  /* Finish output file, release working storage, etc */
+  (*cinfo->methods->write_file_trailer) (cinfo);
+  (*cinfo->methods->colorin_term) (cinfo);
+  (*cinfo->methods->input_term) (cinfo);
+
+  /* My, that was easy, wasn't it? */
+}
diff --git a/jcmcu.c b/jcmcu.c
new file mode 100644
index 0000000..1400eab
--- /dev/null
+++ b/jcmcu.c
@@ -0,0 +1,212 @@
+/*
+ * jcmcu.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains MCU extraction routines and quantization scaling.
+ * These routines are invoked via the extract_MCUs and
+ * extract_init/term methods.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * If this file is compiled with -DDCT_ERR_STATS, it will reverse-DCT each
+ * block and sum the total errors across the whole picture.  This provides
+ * a convenient method of using real picture data to test the roundoff error
+ * of a DCT algorithm.  DCT_ERR_STATS should *not* be defined for a production
+ * compression program, since compression is much slower with it defined.
+ * Also note that jrevdct.o must be linked into the compressor when this
+ * switch is defined.
+ */
+
+#ifdef DCT_ERR_STATS
+static int dcterrorsum;		/* these hold the error statistics */
+static int dcterrormax;
+static int dctcoefcount;	/* This will probably overflow on a 16-bit-int machine */
+#endif
+
+
+/* ZAG[i] is the natural-order position of the i'th element of zigzag order. */
+
+static const short ZAG[DCTSIZE2] = {
+  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
+};
+
+
+LOCAL void
+extract_block (JSAMPARRAY input_data, int start_row, long start_col,
+	       JBLOCK output_data, QUANT_TBL_PTR quanttbl)
+/* Extract one 8x8 block from the specified location in the sample array; */
+/* perform forward DCT, quantization scaling, and zigzag reordering on it. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  DCTBLOCK block;
+#ifdef DCT_ERR_STATS
+  DCTBLOCK svblock;		/* saves input data for comparison */
+#endif
+
+  { register JSAMPROW elemptr;
+    register DCTELEM *localblkptr = block;
+#if DCTSIZE != 8
+    register short elemc;
+#endif
+    register short elemr;
+
+    for (elemr = DCTSIZE; elemr > 0; elemr--) {
+      elemptr = input_data[start_row++] + start_col;
+#if DCTSIZE == 8		/* unroll the inner loop */
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      *localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+#else
+      for (elemc = DCTSIZE; elemc > 0; elemc--) {
+	*localblkptr++ = (DCTELEM) GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+      }
+#endif
+    }
+  }
+
+#ifdef DCT_ERR_STATS
+  memcpy((void *) svblock, (void *) block, SIZEOF(DCTBLOCK));
+#endif
+
+  j_fwd_dct(block);
+
+  { register JCOEF temp;
+    register short i;
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      temp = (JCOEF) block[ZAG[i]];
+      /* divide by *quanttbl, ensuring proper rounding */
+      if (temp < 0) {
+	temp = -temp;
+	temp += *quanttbl>>1;
+	temp /= *quanttbl;
+	temp = -temp;
+      } else {
+	temp += *quanttbl>>1;
+	temp /= *quanttbl;
+      }
+      *output_data++ = temp;
+      quanttbl++;
+    }
+  }
+
+#ifdef DCT_ERR_STATS
+  j_rev_dct(block);
+
+  { register int diff;
+    register short i;
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      diff = block[i] - svblock[i];
+      if (diff < 0) diff = -diff;
+      dcterrorsum += diff;
+      if (dcterrormax < diff) dcterrormax = diff;
+    }
+    dctcoefcount += DCTSIZE2;
+  }
+#endif
+}
+
+
+/*
+ * Extract samples in MCU order, process & hand off to output_method.
+ * The input is always exactly N MCU rows worth of data.
+ */
+
+METHODDEF void
+extract_MCUs (compress_info_ptr cinfo,
+	      JSAMPIMAGE image_data,
+	      int num_mcu_rows,
+	      MCU_output_method_ptr output_method)
+{
+  JBLOCK MCU_data[MAX_BLOCKS_IN_MCU];
+  int mcurow;
+  long mcuindex;
+  short blkn, ci, xpos, ypos;
+  jpeg_component_info * compptr;
+  QUANT_TBL_PTR quant_ptr;
+
+  for (mcurow = 0; mcurow < num_mcu_rows; mcurow++) {
+    for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
+      /* Extract data from the image array, DCT it, and quantize it */
+      blkn = 0;
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	quant_ptr = cinfo->quant_tbl_ptrs[compptr->quant_tbl_no];
+	for (ypos = 0; ypos < compptr->MCU_height; ypos++) {
+	  for (xpos = 0; xpos < compptr->MCU_width; xpos++) {
+	    extract_block(image_data[ci],
+			  (mcurow * compptr->MCU_height + ypos)*DCTSIZE,
+			  (mcuindex * compptr->MCU_width + xpos)*DCTSIZE,
+			  MCU_data[blkn], quant_ptr);
+	    blkn++;
+	  }
+	}
+      }
+      /* Send the MCU whereever the pipeline controller wants it to go */
+      (*output_method) (cinfo, MCU_data);
+    }
+  }
+}
+
+
+/*
+ * Initialize for processing a scan.
+ */
+
+METHODDEF void
+extract_init (compress_info_ptr cinfo)
+{
+  /* no work for now */
+#ifdef DCT_ERR_STATS
+  dcterrorsum = dcterrormax = dctcoefcount = 0;
+#endif
+}
+
+
+/*
+ * Clean up after a scan.
+ */
+
+METHODDEF void
+extract_term (compress_info_ptr cinfo)
+{
+  /* no work for now */
+#ifdef DCT_ERR_STATS
+  TRACEMS3(cinfo->emethods, 0, "DCT roundoff errors = %d/%d,  max = %d",
+	   dcterrorsum, dctcoefcount, dcterrormax);
+#endif
+}
+
+
+
+/*
+ * The method selection routine for MCU extraction.
+ */
+
+GLOBAL void
+jselcmcu (compress_info_ptr cinfo)
+{
+  /* just one implementation for now */
+  cinfo->methods->extract_init = extract_init;
+  cinfo->methods->extract_MCUs = extract_MCUs;
+  cinfo->methods->extract_term = extract_term;
+}
diff --git a/jconfig.h b/jconfig.h
new file mode 100644
index 0000000..3b22acb
--- /dev/null
+++ b/jconfig.h
@@ -0,0 +1,320 @@
+/*
+ * jconfig.h
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains 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.
+ */
+
+/* Does your compiler support function prototypes? */
+/* (If not, you also need to use ansi2knr, see README) */
+
+#ifdef __STDC__			/* ANSI C compilers always have prototypes */
+#define PROTO
+#else
+#ifdef __cplusplus		/* So do C++ compilers */
+#define PROTO
+#endif
+#endif
+
+/* Does your compiler support the declaration "unsigned char" ? */
+/* How about "unsigned short" ? */
+
+#ifdef __STDC__			/* ANSI C compilers must support both */
+#define HAVE_UNSIGNED_CHAR
+#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.
+ * The DCT and IDCT routines will compute wrong values if you get this wrong!
+ */
+
+/* #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 __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			/* Microsoft C and compatibles */
+#define NEED_FAR_POINTERS
+#else
+#ifdef __TURBOC__		/* Turbo C doesn't define MSDOS */
+#define NEED_FAR_POINTERS
+#endif
+#endif
+
+
+/* The next couple of 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
+#else
+#ifdef __TURBOC__		/* Turbo C doesn't define MSDOS */
+#define TWO_FILE_COMMANDLINE
+#endif
+#endif
+#ifdef THINK_C			/* needed for Macintosh too */
+#define TWO_FILE_COMMANDLINE
+#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.
+ */
+
+
+/* If your compiler supports inline functions, define INLINE as
+ * the inline keyword; otherwise define it as empty.
+ */
+
+#ifdef __GNUC__			/* GNU C has inline... */
+#define INLINE inline
+#else				/* ...but I don't think anyone else does. */
+#define INLINE
+#endif
+
+/* 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;
+#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? */
+#undef  QUANT_2PASS_SUPPORTED	/* 2-pass color quantization? (not yet impl.) */
+/* 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 PPM_SUPPORTED		/* PPM/PGM image file format */
+#define GIF_SUPPORTED		/* GIF 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!
+ */
+
+#define EIGHT_BIT_SAMPLES
+#undef  TWELVE_BIT_SAMPLES
+#undef  SIXTEEN_BIT_SAMPLES
+
+
+
+/*
+ * The remaining definitions don't need to be hand-edited in most cases.
+ * You may need to change these if you have a machine with unusual data
+ * types; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* First define the representation of a single pixel element value. */
+
+#ifdef EIGHT_BIT_SAMPLES
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
+ * If you have only signed chars, and you are more worried about speed than
+ * memory usage, it might be a win to make JSAMPLE be short.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value)  (value)
+
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+
+typedef char JSAMPLE;
+#define GETJSAMPLE(value)  (value)
+
+#else /* not CHAR_IS_UNSIGNED */
+
+typedef char JSAMPLE;
+#define GETJSAMPLE(value)  ((value) & 0xFF)
+
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+#define MAXJSAMPLE	255
+#define CENTERJSAMPLE	128
+
+#endif /* EIGHT_BIT_SAMPLES */
+
+
+#ifdef TWELVE_BIT_SAMPLES
+/* JSAMPLE should be the smallest type that will hold the values 0..4095. */
+/* On nearly all machines "short" will do nicely. */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  (value)
+
+#define MAXJSAMPLE	4095
+#define CENTERJSAMPLE	2048
+
+#endif /* TWELVE_BIT_SAMPLES */
+
+
+#ifdef SIXTEEN_BIT_SAMPLES
+/* JSAMPLE should be the smallest type that will hold the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+
+typedef unsigned short JSAMPLE;
+#define GETJSAMPLE(value)  (value)
+
+#else /* not HAVE_UNSIGNED_SHORT */
+
+/* If int is 32 bits this'll be horrendously inefficient storage-wise.
+ * But since we don't actually support 16-bit samples (ie lossless coding) yet,
+ * I'm not going to worry about making a smarter definition ...
+ */
+typedef unsigned int JSAMPLE;
+#define GETJSAMPLE(value)  (value)
+
+#endif /* HAVE_UNSIGNED_SHORT */
+
+#define MAXJSAMPLE	65535
+#define CENTERJSAMPLE	32768
+
+#endif /* SIXTEEN_BIT_SAMPLES */
+
+
+/* Here we define the representation of a DCT frequency coefficient.
+ * This should be a signed 16-bit value; "short" is usually right.
+ * It's important that this be exactly 16 bits, no more and no less;
+ * more will cost you a BIG hit of memory, less will give wrong answers.
+ */
+
+typedef short JCOEF;
+
+
+/* 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
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE.  (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+#ifdef HAVE_UNSIGNED_CHAR
+typedef unsigned char UINT8;
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+typedef char UINT8;
+#else /* not CHAR_IS_UNSIGNED */
+typedef short UINT8;
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+/* INT16 must hold at least the values -32768..32767. */
+
+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. */
+
+typedef long INT32;
diff --git a/jcpipe.c b/jcpipe.c
new file mode 100644
index 0000000..f58e7db
--- /dev/null
+++ b/jcpipe.c
@@ -0,0 +1,715 @@
+/*
+ * jcpipe.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains compression pipeline controllers.
+ * These routines are invoked via the c_pipeline_controller method.
+ *
+ * There are four basic pipeline controllers, one for each combination of:
+ *	single-scan JPEG file (single component or fully interleaved)
+ *  vs. multiple-scan JPEG file (noninterleaved or partially interleaved).
+ *
+ *	optimization of entropy encoding parameters
+ *  vs. usage of default encoding parameters.
+ *
+ * Note that these conditions determine the needs for "big" arrays:
+ * multiple scans imply a big array for splitting the color components;
+ * entropy encoding optimization needs a big array for the MCU data.
+ *
+ * All but the simplest controller (single-scan, no optimization) can be
+ * compiled out through configuration options, if you need to make a minimal
+ * implementation.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * About the data structures:
+ *
+ * The processing chunk size for subsampling is referred to in this file as
+ * a "row group": a row group is defined as Vk (v_samp_factor) sample rows of
+ * any component after subsampling, or Vmax (max_v_samp_factor) unsubsampled
+ * rows.  In an interleaved scan each MCU row contains exactly DCTSIZE row
+ * groups of each component in the scan.  In a noninterleaved scan an MCU row
+ * is one row of blocks, which might not be an integral number of row groups;
+ * for convenience we use a buffer of the same size as in interleaved scans,
+ * and process Vk MCU rows in each burst of subsampling.
+ * To provide context for the subsampling step, we have to retain the last
+ * two row groups of the previous MCU row while reading in the next MCU row
+ * (or set of Vk MCU rows).  To do this without copying data about, we create
+ * a rather strange data structure.  Exactly DCTSIZE+2 row groups of samples
+ * are allocated, but we create two different sets of pointers to this array.
+ * The second set swaps the last two pairs of row groups.  By working
+ * alternately with the two sets of pointers, we can access the data in the
+ * desired order.
+ */
+
+
+
+/*
+ * Utility routines: common code for pipeline controllers
+ */
+
+LOCAL void
+interleaved_scan_setup (compress_info_ptr cinfo)
+/* Compute all derived info for an interleaved (multi-component) scan */
+/* On entry, cinfo->comps_in_scan and cinfo->cur_comp_info[] are set up */
+{
+  short ci, mcublks;
+  jpeg_component_info *compptr;
+
+  if (cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo->emethods, "Too many components for interleaved scan");
+
+  cinfo->MCUs_per_row = (cinfo->image_width
+			 + cinfo->max_h_samp_factor*DCTSIZE - 1)
+			/ (cinfo->max_h_samp_factor*DCTSIZE);
+
+  cinfo->MCU_rows_in_scan = (cinfo->image_height
+			     + cinfo->max_v_samp_factor*DCTSIZE - 1)
+			    / (cinfo->max_v_samp_factor*DCTSIZE);
+  
+  cinfo->blocks_in_MCU = 0;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* for interleaved scan, sampling factors give # of blocks per component */
+    compptr->MCU_width = compptr->h_samp_factor;
+    compptr->MCU_height = compptr->v_samp_factor;
+    compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+    /* compute physical dimensions of component */
+    compptr->subsampled_width = jround_up(compptr->true_comp_width,
+					  (long) (compptr->MCU_width*DCTSIZE));
+    compptr->subsampled_height = jround_up(compptr->true_comp_height,
+					   (long) (compptr->MCU_height*DCTSIZE));
+    /* Sanity check */
+    if (compptr->subsampled_width !=
+	(cinfo->MCUs_per_row * (compptr->MCU_width*DCTSIZE)))
+      ERREXIT(cinfo->emethods, "I'm confused about the image width");
+    /* Prepare array describing MCU composition */
+    mcublks = compptr->MCU_blocks;
+    if (cinfo->blocks_in_MCU + mcublks > MAX_BLOCKS_IN_MCU)
+      ERREXIT(cinfo->emethods, "Sampling factors too large for interleaved scan");
+    while (mcublks-- > 0) {
+      cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+    }
+  }
+
+  (*cinfo->methods->c_per_scan_method_selection) (cinfo);
+}
+
+
+LOCAL void
+noninterleaved_scan_setup (compress_info_ptr cinfo)
+/* Compute all derived info for a noninterleaved (single-component) scan */
+/* On entry, cinfo->comps_in_scan = 1 and cinfo->cur_comp_info[0] is set up */
+{
+  jpeg_component_info *compptr = cinfo->cur_comp_info[0];
+
+  /* for noninterleaved scan, always one block per MCU */
+  compptr->MCU_width = 1;
+  compptr->MCU_height = 1;
+  compptr->MCU_blocks = 1;
+  /* compute physical dimensions of component */
+  compptr->subsampled_width = jround_up(compptr->true_comp_width,
+					(long) DCTSIZE);
+  compptr->subsampled_height = jround_up(compptr->true_comp_height,
+					 (long) DCTSIZE);
+
+  cinfo->MCUs_per_row = compptr->subsampled_width / DCTSIZE;
+  cinfo->MCU_rows_in_scan = compptr->subsampled_height / DCTSIZE;
+
+  /* Prepare array describing MCU composition */
+  cinfo->blocks_in_MCU = 1;
+  cinfo->MCU_membership[0] = 0;
+
+  (*cinfo->methods->c_per_scan_method_selection) (cinfo);
+}
+
+
+
+LOCAL void
+alloc_sampling_buffer (compress_info_ptr cinfo, JSAMPIMAGE fullsize_data[2],
+		       long fullsize_width)
+/* Create a pre-subsampling data buffer having the desired structure */
+/* (see comments at head of file) */
+{
+  short ci, vs, i;
+
+  vs = cinfo->max_v_samp_factor; /* row group height */
+
+  /* Get top-level space for array pointers */
+  fullsize_data[0] = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->num_components * SIZEOF(JSAMPARRAY));
+  fullsize_data[1] = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->num_components * SIZEOF(JSAMPARRAY));
+
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    /* Allocate the real storage */
+    fullsize_data[0][ci] = (*cinfo->emethods->alloc_small_sarray)
+				(fullsize_width,
+				(long) (vs * (DCTSIZE+2)));
+    /* Create space for the scrambled-order pointers */
+    fullsize_data[1][ci] = (JSAMPARRAY) (*cinfo->emethods->alloc_small)
+				(vs * (DCTSIZE+2) * SIZEOF(JSAMPROW));
+    /* Duplicate the first DCTSIZE-2 row groups */
+    for (i = 0; i < vs * (DCTSIZE-2); i++) {
+      fullsize_data[1][ci][i] = fullsize_data[0][ci][i];
+    }
+    /* Copy the last four row groups in swapped order */
+    for (i = 0; i < vs * 2; i++) {
+      fullsize_data[1][ci][vs*DCTSIZE + i] = fullsize_data[0][ci][vs*(DCTSIZE-2) + i];
+      fullsize_data[1][ci][vs*(DCTSIZE-2) + i] = fullsize_data[0][ci][vs*DCTSIZE + i];
+    }
+  }
+}
+
+
+LOCAL void
+free_sampling_buffer (compress_info_ptr cinfo, JSAMPIMAGE fullsize_data[2])
+/* Release a sampling buffer created by alloc_sampling_buffer */
+{
+  short ci, vs;
+
+  vs = cinfo->max_v_samp_factor; /* row group height */
+
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    /* Free the real storage */
+    (*cinfo->emethods->free_small_sarray)
+		(fullsize_data[0][ci], (long) (vs * (DCTSIZE+2)));
+    /* Free the scrambled-order pointers */
+    (*cinfo->emethods->free_small) ((void *) fullsize_data[1][ci]);
+  }
+
+  /* Free the top-level space */
+  (*cinfo->emethods->free_small) ((void *) fullsize_data[0]);
+  (*cinfo->emethods->free_small) ((void *) fullsize_data[1]);
+}
+
+
+LOCAL void
+subsample (compress_info_ptr cinfo,
+	   JSAMPIMAGE fullsize_data, JSAMPIMAGE subsampled_data,
+	   long fullsize_width,
+	   short above, short current, short below, short out)
+/* Do subsampling of a single row group (of each component). */
+/* above, current, below are indexes of row groups in fullsize_data;      */
+/* out is the index of the target row group in subsampled_data.           */
+/* Special case: above, below can be -1 to indicate top, bottom of image. */
+{
+  jpeg_component_info *compptr;
+  JSAMPARRAY above_ptr, below_ptr;
+  JSAMPROW dummy[MAX_SAMP_FACTOR]; /* for subsample expansion at top/bottom */
+  short ci, vs, i;
+
+  vs = cinfo->max_v_samp_factor; /* row group height */
+
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    compptr = & cinfo->comp_info[ci];
+
+    if (above >= 0)
+      above_ptr = fullsize_data[ci] + above * vs;
+    else {
+      /* Top of image: make a dummy above-context with copies of 1st row */
+      /* We assume current=0 in this case */
+      for (i = 0; i < vs; i++)
+	dummy[i] = fullsize_data[ci][0];
+      above_ptr = (JSAMPARRAY) dummy; /* possible near->far pointer conv */
+    }
+
+    if (below >= 0)
+      below_ptr = fullsize_data[ci] + below * vs;
+    else {
+      /* Bot of image: make a dummy below-context with copies of last row */
+      for (i = 0; i < vs; i++)
+	dummy[i] = fullsize_data[ci][(current+1)*vs-1];
+      below_ptr = (JSAMPARRAY) dummy; /* possible near->far pointer conv */
+    }
+
+    (*cinfo->methods->subsample[ci])
+		(cinfo, (int) ci,
+		 fullsize_width, (int) vs,
+		 compptr->subsampled_width, (int) compptr->v_samp_factor,
+		 above_ptr,
+		 fullsize_data[ci] + current * vs,
+		 below_ptr,
+		 subsampled_data[ci] + out * compptr->v_samp_factor);
+  }
+}
+
+
+/* These vars are initialized by the pipeline controller for use by
+ * MCU_output_catcher.
+ * To avoid a lot of row-pointer overhead, we cram as many MCUs into each
+ * row of whole_scan_MCUs as we can get without exceeding 64KB per row.
+ */
+
+#define MAX_WHOLE_ROW_BLOCKS	(65500 / SIZEOF(JBLOCK)) /* max blocks/row */
+
+static big_barray_ptr whole_scan_MCUs; /* Big array for saving the MCUs */
+static int MCUs_in_big_row;	/* # of MCUs in each row of whole_scan_MCUs */
+static long next_whole_row;	/* next row to access in whole_scan_MCUs */
+static int next_MCU_index;	/* next MCU in current row */
+
+
+METHODDEF void
+MCU_output_catcher (compress_info_ptr cinfo, JBLOCK *MCU_data)
+/* Output method for siphoning off extract_MCUs output into a big array */
+{
+  static JBLOCKARRAY rowptr;
+
+  if (next_MCU_index >= MCUs_in_big_row) {
+    rowptr = (*cinfo->emethods->access_big_barray) (whole_scan_MCUs,
+						    next_whole_row, TRUE);
+    next_whole_row++;
+    next_MCU_index = 0;
+  }
+
+  /*
+   * note that on 80x86, the cast applied to MCU_data implies
+   * near to far pointer conversion.
+   */
+  jcopy_block_row((JBLOCKROW) MCU_data,
+		  rowptr[0] + next_MCU_index * cinfo->blocks_in_MCU,
+		  (long) cinfo->blocks_in_MCU);
+  next_MCU_index++;
+}
+
+
+METHODDEF void
+dump_scan_MCUs (compress_info_ptr cinfo, MCU_output_method_ptr output_method)
+/* Dump the MCUs saved in whole_scan_MCUs to the output method. */
+/* The method may be either the entropy encoder or some routine supplied */
+/* by the entropy optimizer. */
+{
+  /* On an 80x86 machine, the entropy encoder expects the passed data block
+   * to be in NEAR memory (for performance reasons), so we have to copy it
+   * back from the big array to a local array.  On less brain-damaged CPUs
+   * we needn't do that.
+   */
+#ifdef NEED_FAR_POINTERS
+  JBLOCK MCU_data[MAX_BLOCKS_IN_MCU];
+#endif
+  long mcurow, mcuindex, next_row;
+  int next_index;
+  JBLOCKARRAY rowptr = NULL;	/* init only to suppress compiler complaint */
+
+  next_row = 0;
+  next_index = MCUs_in_big_row;
+
+  for (mcurow = 0; mcurow < cinfo->MCU_rows_in_scan; mcurow++) {
+    for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
+      if (next_index >= MCUs_in_big_row) {
+	rowptr = (*cinfo->emethods->access_big_barray) (whole_scan_MCUs,
+							next_row, FALSE);
+	next_row++;
+	next_index = 0;
+      }
+#ifdef NEED_FAR_POINTERS
+      jcopy_block_row(rowptr[0] + next_index * cinfo->blocks_in_MCU,
+		      (JBLOCKROW) MCU_data, /* note cast */
+		      (long) cinfo->blocks_in_MCU);
+      (*output_method) (cinfo, MCU_data);
+#else
+      (*output_method) (cinfo, rowptr[0] + next_index * cinfo->blocks_in_MCU);
+#endif
+      next_index++;
+    }
+  }
+}
+
+
+
+/*
+ * Compression pipeline controller used for single-scan files
+ * with no optimization of entropy parameters.
+ */
+
+METHODDEF void
+single_ccontroller (compress_info_ptr cinfo)
+{
+  int rows_in_mem;		/* # of sample rows in full-size buffers */
+  long fullsize_width;		/* # of samples per row in full-size buffers */
+  long cur_pixel_row;		/* counts # of pixel rows processed */
+  long mcu_rows_output;		/* # of MCU rows actually emitted */
+  int mcu_rows_per_loop;	/* # of MCU rows processed per outer loop */
+  /* Work buffer for pre-subsampling data (see comments at head of file) */
+  JSAMPIMAGE fullsize_data[2];
+  /* Work buffer for subsampled data */
+  JSAMPIMAGE subsampled_data;
+  int rows_this_time;
+  short ci, whichss, i;
+
+  /* Prepare for single scan containing all components */
+  if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo->emethods, "Too many components for interleaved scan");
+  cinfo->comps_in_scan = cinfo->num_components;
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+  }
+  if (cinfo->comps_in_scan == 1) {
+    noninterleaved_scan_setup(cinfo);
+    /* Vk block rows constitute the same number of MCU rows */
+    mcu_rows_per_loop = cinfo->cur_comp_info[0]->v_samp_factor;
+  } else {
+    interleaved_scan_setup(cinfo);
+    /* in an interleaved scan, one MCU row contains Vk block rows */
+    mcu_rows_per_loop = 1;
+  }
+
+  /* Compute dimensions of full-size pixel buffers */
+  /* Note these are the same whether interleaved or not. */
+  rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
+  fullsize_width = jround_up(cinfo->image_width,
+			     (long) (cinfo->max_h_samp_factor * DCTSIZE));
+
+  /* Allocate working memory: */
+  /* fullsize_data is sample data before subsampling */
+  alloc_sampling_buffer(cinfo, fullsize_data, fullsize_width);
+  /* subsampled_data is sample data after subsampling */
+  subsampled_data = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->num_components * SIZEOF(JSAMPARRAY));
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    subsampled_data[ci] = (*cinfo->emethods->alloc_small_sarray)
+			(cinfo->comp_info[ci].subsampled_width,
+			 (long) (cinfo->comp_info[ci].v_samp_factor * DCTSIZE));
+  }
+
+  /* Tell the memory manager to instantiate big arrays.
+   * We don't need any big arrays in this controller,
+   * but some other module (like the input file reader) may need one.
+   */
+  (*cinfo->emethods->alloc_big_arrays)
+	((long) 0,				/* no more small sarrays */
+	 (long) 0,				/* no more small barrays */
+	 (long) 0);				/* no more "medium" objects */
+
+  /* Initialize output file & do per-scan object init */
+
+  (*cinfo->methods->write_scan_header) (cinfo);
+  cinfo->methods->entropy_output = cinfo->methods->write_jpeg_data;
+  (*cinfo->methods->entropy_encoder_init) (cinfo);
+  (*cinfo->methods->subsample_init) (cinfo);
+  (*cinfo->methods->extract_init) (cinfo);
+
+  /* Loop over input image: rows_in_mem pixel rows are processed per loop */
+
+  mcu_rows_output = 0;
+  whichss = 1;			/* arrange to start with fullsize_data[0] */
+
+  for (cur_pixel_row = 0; cur_pixel_row < cinfo->image_height;
+       cur_pixel_row += rows_in_mem) {
+    whichss ^= 1;		/* switch to other fullsize_data buffer */
+    
+    /* Obtain rows_this_time pixel rows and expand to rows_in_mem rows. */
+    /* Then we have exactly DCTSIZE row groups for subsampling. */   
+    rows_this_time = MIN(rows_in_mem, cinfo->image_height - cur_pixel_row);
+ 
+    (*cinfo->methods->get_sample_rows) (cinfo, rows_this_time,
+					fullsize_data[whichss]);
+    (*cinfo->methods->edge_expand) (cinfo,
+				    cinfo->image_width, rows_this_time,
+				    fullsize_width, rows_in_mem,
+				    fullsize_data[whichss]);
+    
+    /* Subsample the data (all components) */
+    /* First time through is a special case */
+    
+    if (cur_pixel_row) {
+      /* Subsample last row group of previous set */
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
+		(short) (DCTSIZE-1));
+      /* and dump the previous set's subsampled data */
+      (*cinfo->methods->extract_MCUs) (cinfo, subsampled_data, 
+				       mcu_rows_per_loop,
+				       cinfo->methods->entropy_encode);
+      mcu_rows_output += mcu_rows_per_loop;
+      /* Subsample first row group of this set */
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) (DCTSIZE+1), (short) 0, (short) 1,
+		(short) 0);
+    } else {
+      /* Subsample first row group with dummy above-context */
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) (-1), (short) 0, (short) 1,
+		(short) 0);
+    }
+    /* Subsample second through next-to-last row groups of this set */
+    for (i = 1; i <= DCTSIZE-2; i++) {
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) (i-1), (short) i, (short) (i+1),
+		(short) i);
+    }
+  } /* end of outer loop */
+  
+  /* Subsample the last row group with dummy below-context */
+  /* Note whichss points to last buffer side used */
+  subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+	    (short) (DCTSIZE-2), (short) (DCTSIZE-1), (short) (-1),
+	    (short) (DCTSIZE-1));
+  /* Dump the remaining data (may be less than full height if uninterleaved) */
+  (*cinfo->methods->extract_MCUs) (cinfo, subsampled_data, 
+		(int) (cinfo->MCU_rows_in_scan - mcu_rows_output),
+		cinfo->methods->entropy_encode);
+
+  /* Finish output file */
+  (*cinfo->methods->extract_term) (cinfo);
+  (*cinfo->methods->subsample_term) (cinfo);
+  (*cinfo->methods->entropy_encoder_term) (cinfo);
+  (*cinfo->methods->write_scan_trailer) (cinfo);
+
+  /* Release working memory */
+  free_sampling_buffer(cinfo, fullsize_data);
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    (*cinfo->emethods->free_small_sarray)
+		(subsampled_data[ci],
+		 (long) (cinfo->comp_info[ci].v_samp_factor * DCTSIZE));
+  }
+  (*cinfo->emethods->free_small) ((void *) subsampled_data);
+}
+
+
+/*
+ * Compression pipeline controller used for single-scan files
+ * with optimization of entropy parameters.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+METHODDEF void
+single_eopt_ccontroller (compress_info_ptr cinfo)
+{
+  int rows_in_mem;		/* # of sample rows in full-size buffers */
+  long fullsize_width;		/* # of samples per row in full-size buffers */
+  long cur_pixel_row;		/* counts # of pixel rows processed */
+  long mcu_rows_output;		/* # of MCU rows actually emitted */
+  int mcu_rows_per_loop;	/* # of MCU rows processed per outer loop */
+  /* Work buffer for pre-subsampling data (see comments at head of file) */
+  JSAMPIMAGE fullsize_data[2];
+  /* Work buffer for subsampled data */
+  JSAMPIMAGE subsampled_data;
+  int rows_this_time;
+  int blocks_in_big_row;
+  short ci, whichss, i;
+
+  /* Prepare for single scan containing all components */
+  if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo->emethods, "Too many components for interleaved scan");
+  cinfo->comps_in_scan = cinfo->num_components;
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+  }
+  if (cinfo->comps_in_scan == 1) {
+    noninterleaved_scan_setup(cinfo);
+    /* Vk block rows constitute the same number of MCU rows */
+    mcu_rows_per_loop = cinfo->cur_comp_info[0]->v_samp_factor;
+  } else {
+    interleaved_scan_setup(cinfo);
+    /* in an interleaved scan, one MCU row contains Vk block rows */
+    mcu_rows_per_loop = 1;
+  }
+
+  /* Compute dimensions of full-size pixel buffers */
+  /* Note these are the same whether interleaved or not. */
+  rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
+  fullsize_width = jround_up(cinfo->image_width,
+			     (long) (cinfo->max_h_samp_factor * DCTSIZE));
+
+  /* Allocate working memory: */
+  /* fullsize_data is sample data before subsampling */
+  alloc_sampling_buffer(cinfo, fullsize_data, fullsize_width);
+  /* subsampled_data is sample data after subsampling */
+  subsampled_data = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->num_components * SIZEOF(JSAMPARRAY));
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    subsampled_data[ci] = (*cinfo->emethods->alloc_small_sarray)
+			(cinfo->comp_info[ci].subsampled_width,
+			 (long) (cinfo->comp_info[ci].v_samp_factor * DCTSIZE));
+  }
+
+  /* Figure # of MCUs to be packed in a row of whole_scan_MCUs */
+  MCUs_in_big_row = MAX_WHOLE_ROW_BLOCKS / cinfo->blocks_in_MCU;
+  blocks_in_big_row = MCUs_in_big_row * cinfo->blocks_in_MCU;
+
+  /* Request a big array: whole_scan_MCUs saves the MCU data for the scan */
+  whole_scan_MCUs = (*cinfo->emethods->request_big_barray)
+		((long) blocks_in_big_row,
+		 (long) (cinfo->MCUs_per_row * cinfo->MCU_rows_in_scan
+			 + MCUs_in_big_row-1) / MCUs_in_big_row,
+		 1L);		/* unit height is 1 row */
+
+  next_whole_row = 0;		/* init output ptr for MCU_output_catcher */
+  next_MCU_index = MCUs_in_big_row; /* forces access on first call! */
+
+  /* Tell the memory manager to instantiate big arrays */
+  (*cinfo->emethods->alloc_big_arrays)
+	((long) 0,				/* no more small sarrays */
+	 (long) 0,				/* no more small barrays */
+	 (long) 0);				/* no more "medium" objects */
+
+  /* Do per-scan object init */
+
+  (*cinfo->methods->subsample_init) (cinfo);
+  (*cinfo->methods->extract_init) (cinfo);
+
+  /* Loop over input image: rows_in_mem pixel rows are processed per loop */
+  /* MCU data goes into whole_scan_MCUs, not to the entropy encoder */
+
+  mcu_rows_output = 0;
+  whichss = 1;			/* arrange to start with fullsize_data[0] */
+
+  for (cur_pixel_row = 0; cur_pixel_row < cinfo->image_height;
+       cur_pixel_row += rows_in_mem) {
+    whichss ^= 1;		/* switch to other fullsize_data buffer */
+    
+    /* Obtain rows_this_time pixel rows and expand to rows_in_mem rows. */
+    /* Then we have exactly DCTSIZE row groups for subsampling. */   
+    rows_this_time = MIN(rows_in_mem, cinfo->image_height - cur_pixel_row);
+ 
+    (*cinfo->methods->get_sample_rows) (cinfo, rows_this_time,
+					fullsize_data[whichss]);
+    (*cinfo->methods->edge_expand) (cinfo,
+				    cinfo->image_width, rows_this_time,
+				    fullsize_width, rows_in_mem,
+				    fullsize_data[whichss]);
+    
+    /* Subsample the data (all components) */
+    /* First time through is a special case */
+    
+    if (cur_pixel_row) {
+      /* Subsample last row group of previous set */
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
+		(short) (DCTSIZE-1));
+      /* and dump the previous set's subsampled data */
+      (*cinfo->methods->extract_MCUs) (cinfo, subsampled_data, 
+				       mcu_rows_per_loop,
+				       MCU_output_catcher);
+      mcu_rows_output += mcu_rows_per_loop;
+      /* Subsample first row group of this set */
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) (DCTSIZE+1), (short) 0, (short) 1,
+		(short) 0);
+    } else {
+      /* Subsample first row group with dummy above-context */
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) (-1), (short) 0, (short) 1,
+		(short) 0);
+    }
+    /* Subsample second through next-to-last row groups of this set */
+    for (i = 1; i <= DCTSIZE-2; i++) {
+      subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+		(short) (i-1), (short) i, (short) (i+1),
+		(short) i);
+    }
+  } /* end of outer loop */
+  
+  /* Subsample the last row group with dummy below-context */
+  /* Note whichss points to last buffer side used */
+  subsample(cinfo, fullsize_data[whichss], subsampled_data, fullsize_width,
+	    (short) (DCTSIZE-2), (short) (DCTSIZE-1), (short) (-1),
+	    (short) (DCTSIZE-1));
+  /* Dump the remaining data (may be less than full height if uninterleaved) */
+  (*cinfo->methods->extract_MCUs) (cinfo, subsampled_data, 
+		(int) (cinfo->MCU_rows_in_scan - mcu_rows_output),
+		MCU_output_catcher);
+
+  /* Clean up after that stuff, then find the optimal entropy parameters */
+
+  (*cinfo->methods->extract_term) (cinfo);
+  (*cinfo->methods->subsample_term) (cinfo);
+
+  (*cinfo->methods->entropy_optimize) (cinfo, dump_scan_MCUs);
+
+  /* Emit scan to output file */
+  /* Note: we can't do write_scan_header until entropy parameters are set! */
+
+  (*cinfo->methods->write_scan_header) (cinfo);
+  cinfo->methods->entropy_output = cinfo->methods->write_jpeg_data;
+  (*cinfo->methods->entropy_encoder_init) (cinfo);
+  dump_scan_MCUs(cinfo, cinfo->methods->entropy_encode);
+  (*cinfo->methods->entropy_encoder_term) (cinfo);
+  (*cinfo->methods->write_scan_trailer) (cinfo);
+
+  /* Release working memory */
+  free_sampling_buffer(cinfo, fullsize_data);
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    (*cinfo->emethods->free_small_sarray)
+		(subsampled_data[ci],
+		 (long) (cinfo->comp_info[ci].v_samp_factor * DCTSIZE));
+  }
+  (*cinfo->emethods->free_small) ((void *) subsampled_data);
+  (*cinfo->emethods->free_big_barray) (whole_scan_MCUs);
+}
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * Compression pipeline controller used for multiple-scan files
+ * with no optimization of entropy parameters.
+ */
+
+#ifdef MULTISCAN_FILES_SUPPORTED
+
+METHODDEF void
+multi_ccontroller (compress_info_ptr cinfo)
+{
+  ERREXIT(cinfo->emethods, "Not implemented yet");
+}
+
+#endif /* MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * Compression pipeline controller used for multiple-scan files
+ * with optimization of entropy parameters.
+ */
+
+#ifdef MULTISCAN_FILES_SUPPORTED
+#ifdef ENTROPY_OPT_SUPPORTED
+
+METHODDEF void
+multi_eopt_ccontroller (compress_info_ptr cinfo)
+{
+  ERREXIT(cinfo->emethods, "Not implemented yet");
+}
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+#endif /* MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * The method selection routine for compression pipeline controllers.
+ */
+
+GLOBAL void
+jselcpipeline (compress_info_ptr cinfo)
+{
+  if (cinfo->interleave || cinfo->num_components == 1) {
+    /* single scan needed */
+#ifdef ENTROPY_OPT_SUPPORTED
+    if (cinfo->optimize_coding)
+      cinfo->methods->c_pipeline_controller = single_eopt_ccontroller;
+    else
+#endif
+      cinfo->methods->c_pipeline_controller = single_ccontroller;
+  } else {
+    /* multiple scans needed */
+#ifdef MULTISCAN_FILES_SUPPORTED
+#ifdef ENTROPY_OPT_SUPPORTED
+    if (cinfo->optimize_coding)
+      cinfo->methods->c_pipeline_controller = multi_eopt_ccontroller;
+    else
+#endif
+      cinfo->methods->c_pipeline_controller = multi_ccontroller;
+#else
+    ERREXIT(cinfo->emethods, "Multiple-scan support was not compiled");
+#endif
+  }
+}
diff --git a/jcsample.c b/jcsample.c
new file mode 100644
index 0000000..d23e23a
--- /dev/null
+++ b/jcsample.c
@@ -0,0 +1,135 @@
+/*
+ * jcsample.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains subsampling routines.
+ * These routines are invoked via the subsample and
+ * subsample_init/term methods.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * Initialize for subsampling a scan.
+ */
+
+METHODDEF void
+subsample_init (compress_info_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+/*
+ * Subsample pixel values of a single component.
+ * This version only handles integral sampling ratios.
+ */
+
+METHODDEF void
+subsample (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)
+{
+  jpeg_component_info * compptr = cinfo->cur_comp_info[which_component];
+  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
+  long outcol;
+  JSAMPROW inptr, outptr;
+  INT32 outvalue;
+
+  /* TEMP FOR DEBUGGING PIPELINE CONTROLLER */
+  if (output_rows != compptr->v_samp_factor ||
+      input_rows != cinfo->max_v_samp_factor ||
+      (output_cols % compptr->h_samp_factor) != 0 ||
+      (input_cols % cinfo->max_h_samp_factor) != 0 ||
+      input_cols*compptr->h_samp_factor != output_cols*cinfo->max_h_samp_factor)
+    ERREXIT(cinfo->emethods, "Bogus subsample parameters");
+
+  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+  numpix = h_expand * v_expand;
+  numpix2 = numpix/2;
+
+  inrow = 0;
+  for (outrow = 0; outrow < output_rows; outrow++) {
+    outptr = output_data[outrow];
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      outvalue = 0;
+      for (v = 0; v < v_expand; v++) {
+	inptr = input_data[inrow+v] + (outcol*h_expand);
+	for (h = 0; h < h_expand; h++) {
+	  outvalue += GETJSAMPLE(*inptr++);
+	}
+      }
+      *outptr++ = (outvalue + numpix2) / numpix;
+    }
+    inrow += v_expand;
+  }
+}
+
+
+/*
+ * Subsample pixel values of a single component.
+ * This version handles the special case of a full-size component.
+ */
+
+METHODDEF void
+fullsize_subsample (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)
+{
+  if (input_cols != output_cols || input_rows != output_rows) /* DEBUG */
+    ERREXIT(cinfo->emethods, "Pipeline controller messed up");
+
+  jcopy_sample_rows(input_data, 0, output_data, 0, output_rows, output_cols);
+}
+
+
+/*
+ * Clean up after a scan.
+ */
+
+METHODDEF void
+subsample_term (compress_info_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+
+/*
+ * The method selection routine for subsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL void
+jselsubsample (compress_info_ptr cinfo)
+{
+  short ci;
+  jpeg_component_info * compptr;
+
+  if (cinfo->CCIR601_sampling)
+    ERREXIT(cinfo->emethods, "CCIR601 subsampling not implemented yet");
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+	compptr->v_samp_factor == cinfo->max_v_samp_factor)
+      cinfo->methods->subsample[ci] = fullsize_subsample;
+    else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+	     (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0)
+      cinfo->methods->subsample[ci] = subsample;
+    else
+      ERREXIT(cinfo->emethods, "Fractional subsampling not implemented yet");
+  }
+
+  cinfo->methods->subsample_init = subsample_init;
+  cinfo->methods->subsample_term = subsample_term;
+}
diff --git a/jdarith.c b/jdarith.c
new file mode 100644
index 0000000..0f19be8
--- /dev/null
+++ b/jdarith.c
@@ -0,0 +1,42 @@
+/*
+ * jdarith.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains arithmetic entropy decoding routines.
+ * These routines are invoked via the methods entropy_decode
+ * and entropy_decoder_init/term.
+ */
+
+#include "jinclude.h"
+
+#ifdef ARITH_CODING_SUPPORTED
+
+
+/*
+ * The arithmetic coding option of the JPEG standard specifies Q-coding,
+ * which is covered by patents held by IBM (and possibly AT&T and Mitsubishi).
+ * At this time it does not appear to be legal for the Independent JPEG
+ * Group to distribute software that implements arithmetic coding.
+ * We have therefore removed arithmetic coding support from the
+ * distributed source code.
+ *
+ * We're not happy about it either.
+ */
+
+
+/*
+ * The method selection routine for arithmetic entropy decoding.
+ */
+
+GLOBAL void
+jseldarithmetic (decompress_info_ptr cinfo)
+{
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo->emethods, "Sorry, there are legal restrictions on arithmetic coding");
+  }
+}
+
+#endif /* ARITH_CODING_SUPPORTED */
diff --git a/jdcolor.c b/jdcolor.c
new file mode 100644
index 0000000..a39ebff
--- /dev/null
+++ b/jdcolor.c
@@ -0,0 +1,194 @@
+/*
+ * jdcolor.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains output colorspace conversion routines.
+ * These routines are invoked via the methods color_convert
+ * and colorout_init/term.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * Initialize for colorspace conversion.
+ */
+
+METHODDEF void
+colorout_init (decompress_info_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ * This version handles YCbCr -> RGB conversion.
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ */
+
+METHODDEF void
+ycc_rgb_convert (decompress_info_ptr cinfo, int num_rows,
+		 JSAMPIMAGE input_data, JSAMPIMAGE output_data)
+{
+  register INT32 y, u, v, x;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JSAMPROW outptr0, outptr1, outptr2;
+  register long col;
+  register long width = cinfo->image_width;
+  register int row;
+  
+  for (row = 0; row < num_rows; row++) {
+    inptr0 = input_data[0][row];
+    inptr1 = input_data[1][row];
+    inptr2 = input_data[2][row];
+    outptr0 = output_data[0][row];
+    outptr1 = output_data[1][row];
+    outptr2 = output_data[2][row];
+    for (col = width; col > 0; col--) {
+      y = GETJSAMPLE(*inptr0++);
+      u = (int) GETJSAMPLE(*inptr1++) - CENTERJSAMPLE;
+      v = (int) GETJSAMPLE(*inptr2++) - CENTERJSAMPLE;
+      /* Note: if the inputs were computed directly from RGB values,
+       * range-limiting would be unnecessary here; but due to possible
+       * noise in the DCT/IDCT phase, we do need to apply range limits.
+       */
+      y *= 1024;	/* in case compiler can't spot common subexpression */
+      x = y          + 1436*v + 512; /* red */
+      if (x < 0) x = 0;
+      if (x > ((INT32) MAXJSAMPLE*1024)) x = (INT32) MAXJSAMPLE*1024;
+      *outptr0++ = x >> 10;
+      x = y -  352*u -  731*v + 512; /* green */
+      if (x < 0) x = 0;
+      if (x > ((INT32) MAXJSAMPLE*1024)) x = (INT32) MAXJSAMPLE*1024;
+      *outptr1++ = x >> 10;
+      x = y + 1815*u          + 512; /* blue */
+      if (x < 0) x = 0;
+      if (x > ((INT32) MAXJSAMPLE*1024)) x = (INT32) MAXJSAMPLE*1024;
+      *outptr2++ = x >> 10;
+    }
+  }
+}
+
+
+/*
+ * Color conversion for no colorspace change: just copy the data.
+ */
+
+METHODDEF void
+null_convert (decompress_info_ptr cinfo, int num_rows,
+	      JSAMPIMAGE input_data, JSAMPIMAGE output_data)
+{
+  short ci;
+
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    jcopy_sample_rows(input_data[ci], 0, output_data[ci], 0,
+		      num_rows, cinfo->image_width);
+  }
+}
+
+
+/*
+ * Color conversion for grayscale: just copy the data.
+ * This also works for YCbCr/YIQ -> grayscale conversion, in which
+ * we just copy the Y (luminance) component and ignore chrominance.
+ */
+
+METHODDEF void
+grayscale_convert (decompress_info_ptr cinfo, int num_rows,
+		   JSAMPIMAGE input_data, JSAMPIMAGE output_data)
+{
+  jcopy_sample_rows(input_data[0], 0, output_data[0], 0,
+		    num_rows, cinfo->image_width);
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+colorout_term (decompress_info_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * The method selection routine for output colorspace conversion.
+ */
+
+GLOBAL void
+jseldcolor (decompress_info_ptr cinfo)
+{
+  /* Make sure num_components agrees with jpeg_color_space */
+  switch (cinfo->jpeg_color_space) {
+  case CS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
+    break;
+
+  case CS_RGB:
+  case CS_YIQ:
+  case CS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
+    break;
+
+  case CS_CMYK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo->emethods, "Bogus JPEG colorspace");
+    break;
+
+  default:
+    ERREXIT(cinfo->emethods, "Unsupported JPEG colorspace");
+    break;
+  }
+
+  /* Set color_out_comps and conversion method based on requested space */
+  switch (cinfo->out_color_space) {
+  case CS_GRAYSCALE:
+    cinfo->color_out_comps = 1;
+    if (cinfo->jpeg_color_space == CS_GRAYSCALE ||
+	cinfo->jpeg_color_space == CS_YCbCr ||
+	cinfo->jpeg_color_space == CS_YIQ)
+      cinfo->methods->color_convert = grayscale_convert;
+    else
+      ERREXIT(cinfo->emethods, "Unsupported color conversion request");
+    break;
+
+  case CS_RGB:
+    cinfo->color_out_comps = 3;
+    if (cinfo->jpeg_color_space == CS_YCbCr)
+      cinfo->methods->color_convert = ycc_rgb_convert;
+    else if (cinfo->jpeg_color_space == CS_RGB)
+      cinfo->methods->color_convert = null_convert;
+    else
+      ERREXIT(cinfo->emethods, "Unsupported color conversion request");
+    break;
+
+  case CS_CMYK:
+    cinfo->color_out_comps = 4;
+    if (cinfo->jpeg_color_space == CS_CMYK)
+      cinfo->methods->color_convert = null_convert;
+    else
+      ERREXIT(cinfo->emethods, "Unsupported color conversion request");
+    break;
+
+  default:
+    ERREXIT(cinfo->emethods, "Unsupported output colorspace");
+    break;
+  }
+
+  if (cinfo->quantize_colors)
+    cinfo->final_out_comps = 1;	/* single colormapped output component */
+  else
+    cinfo->final_out_comps = cinfo->color_out_comps;
+
+  cinfo->methods->colorout_init = colorout_init;
+  cinfo->methods->colorout_term = colorout_term;
+}
diff --git a/jdhuff.c b/jdhuff.c
new file mode 100644
index 0000000..e9af688
--- /dev/null
+++ b/jdhuff.c
@@ -0,0 +1,318 @@
+/*
+ * jdhuff.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy decoding routines.
+ * These routines are invoked via the methods entropy_decode
+ * and entropy_decoder_init/term.
+ */
+
+#include "jinclude.h"
+
+
+/* Static variables to avoid passing 'round extra parameters */
+
+static decompress_info_ptr dcinfo;
+
+static unsigned int get_buffer; /* current bit-extraction buffer */
+static int bits_left;		/* # of unused bits in it */
+
+
+LOCAL void
+fix_huff_tbl (HUFF_TBL * htbl)
+/* Compute derived values for a Huffman table */
+{
+  int p, i, l, lastp, si;
+  char huffsize[257];
+  UINT16 huffcode[257];
+  UINT16 code;
+  
+  /* Figure 7.3.5.4.2.1: make table of Huffman code length for each symbol */
+  /* Note that this is in code-length order. */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    for (i = 1; i <= htbl->bits[l]; i++)
+      huffsize[p++] = l;
+  }
+  huffsize[p] = 0;
+  lastp = p;
+  
+  /* Figure 7.3.5.4.2.2: generate the codes themselves */
+  /* Note that this is in code-length order. */
+  
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (huffsize[p] == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    code <<= 1;
+    si++;
+  }
+  
+  /* Figure 7.3.5.4.2.3: generate encoding tables */
+  /* These are code and size indexed by symbol value */
+
+  for (p = 0; p < lastp; p++) {
+    htbl->ehufco[htbl->huffval[p]] = huffcode[p];
+    htbl->ehufsi[htbl->huffval[p]] = huffsize[p];
+  }
+  
+  /* Figure 13.4.2.3.1: generate decoding tables */
+
+  p = 0;
+  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 */
+      p += htbl->bits[l];
+      htbl->maxcode[l] = huffcode[p-1];	/* maximum code of length l */
+    } else {
+      htbl->maxcode[l] = -1;
+    }
+  }
+}
+
+
+/* Extract the next N bits from the input stream (N <= 8) */
+
+LOCAL int
+get_bits (int nbits)
+{
+  int result;
+  
+  while (nbits > bits_left) {
+    int c = JGETC(dcinfo);
+    
+    get_buffer = (get_buffer << 8) + c;
+    bits_left += 8;
+    /* If it's 0xFF, check and discard stuffed zero byte */
+    if (c == 0xff) {
+      c = JGETC(dcinfo);  /* Byte stuffing */
+      if (c != 0)
+	ERREXIT1(dcinfo->emethods,
+		 "Unexpected marker 0x%02x in compressed data", c);
+    }
+  }
+  
+  bits_left -= nbits;
+  result = (get_buffer >> bits_left) & ((1 << nbits) - 1);
+  return result;
+}
+
+/* Macro to make things go at some speed! */
+
+#define get_bit()	(bits_left ? \
+			 ((get_buffer >> (--bits_left)) & 1) : \
+			 get_bits(1))
+
+
+/* Figure 13.4.2.3.2: extract next coded symbol from input stream */
+  
+LOCAL int
+huff_DECODE (HUFF_TBL * htbl)
+{
+  int l, p;
+  INT32 code;
+  
+  code = get_bit();
+  l = 1;
+  while (code > htbl->maxcode[l]) {
+    code = (code << 1) + get_bit();
+    l++;
+  }
+  
+  p = htbl->valptr[l] + (code - htbl->mincode[l]);
+  
+  return htbl->huffval[p];
+}
+
+
+/* Figure 13.4.2.1.1: extend sign bit */
+
+#define huff_EXTEND(x, s)	((x) < (1 << ((s)-1)) ? \
+				 (x) + (-1 << (s)) + 1 : \
+				 (x))
+
+
+/* Decode a single block's worth of coefficients */
+/* Note that only the difference is returned for the DC coefficient */
+
+LOCAL void
+decode_one_block (JBLOCK block, HUFF_TBL *dctbl, HUFF_TBL *actbl)
+{
+  int s, k, r, n;
+
+  /* zero out the coefficient block */
+
+  MEMZERO((void *) block, SIZEOF(JBLOCK));
+  
+  /* Section 13.4.2.1: decode the DC coefficient difference */
+
+  s = huff_DECODE(dctbl);
+  r = get_bits(s);
+  block[0] = huff_EXTEND(r, s);
+  
+  /* Section 13.4.2.2: decode the AC coefficients */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    r = huff_DECODE(actbl);
+    
+    s = r & 15;
+    n = r >> 4;
+    
+    if (s) {
+      k = k + n;
+      r = get_bits(s);
+      block[k] = huff_EXTEND(r, s);
+    } else {
+      if (n != 15)
+	break;
+      k += 15;
+    }
+  }
+}
+
+
+/*
+ * 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)
+{
+  int c, nbytes;
+  short ci;
+
+  /* Throw away any partial unread byte */
+  bits_left = 0;
+
+  /* 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 */
+
+  if (c != (RST0 + cinfo->next_restart_num))
+    ERREXIT2(cinfo->emethods, "Found 0x%02x marker instead of RST%d",
+	     c, cinfo->next_restart_num);
+
+  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);
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+    cinfo->last_dc_val[ci] = 0;
+
+  /* Update restart state */
+  cinfo->restarts_to_go = cinfo->restart_interval;
+  cinfo->next_restart_num++;
+  cinfo->next_restart_num &= 7;
+}
+
+
+/*
+ * Decode and return one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF void
+huff_decode (decompress_info_ptr cinfo, JBLOCK *MCU_data)
+{
+  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--;
+  }
+
+  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];
+  }
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF void
+huff_decoder_term (decompress_info_ptr cinfo)
+{
+  /* No work needed */
+}
+
+
+/*
+ * The method selection routine for Huffman entropy decoding.
+ */
+
+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 --git a/jdmain.c b/jdmain.c
new file mode 100644
index 0000000..109d124
--- /dev/null
+++ b/jdmain.c
@@ -0,0 +1,289 @@
+/*
+ * jdmain.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a trivial test user interface for the JPEG decompressor.
+ * It should work on any system with Unix- or MS-DOS-style command lines.
+ *
+ * Two different command line styles are permitted, depending on the
+ * compile-time switch TWO_FILE_COMMANDLINE:
+ *	djpeg [options]  inputfile outputfile
+ *	djpeg [options]  [inputfile]
+ * In the second style, output is always to standard output, which you'd
+ * normally redirect to a file or pipe to some other program.  Input is
+ * either from a named file or from standard input (typically redirected).
+ * The second style is convenient on Unix but is unhelpful on systems that
+ * don't support pipes.  Also, you MUST use the first style if your system
+ * doesn't do binary I/O to stdin/stdout.
+ */
+
+#include "jinclude.h"
+#ifdef __STDC__
+#include <stdlib.h>		/* to declare exit() */
+#endif
+
+#ifdef THINK_C
+#include <console.h>		/* command-line reader for Macintosh */
+#endif
+
+#ifdef DONT_USE_B_MODE		/* define mode parameters for fopen() */
+#define READ_BINARY	"r"
+#define WRITE_BINARY	"w"
+#else
+#define READ_BINARY	"rb"
+#define WRITE_BINARY	"wb"
+#endif
+
+
+/*
+ * If your system has getopt(3), you can use your library version by
+ * defining HAVE_GETOPT.  By default, we use the PD 'egetopt'.
+ */
+
+#ifdef HAVE_GETOPT
+extern int getopt PP((int argc, char **argv, char *optstring));
+extern char * optarg;
+extern int optind;
+#else
+#include "egetopt.c"
+#define getopt(argc,argv,opt)	egetopt(argc,argv,opt)
+#endif
+
+
+typedef enum {			/* defines known output image formats */
+	FMT_PPM,		/* PPM/PGM (PBMPLUS formats) */
+	FMT_GIF,		/* GIF format */
+	FMT_TIFF		/* TIFF format */
+} IMAGE_FORMATS;
+
+static IMAGE_FORMATS requested_fmt;
+
+
+/*
+ * This routine gets control after the input file header has been read.
+ * It must determine what output file format is to be written,
+ * and make any other decompression parameter changes that are desirable.
+ */
+
+METHODDEF void
+d_ui_method_selection (decompress_info_ptr cinfo)
+{
+  /* if grayscale or CMYK input, force similar output; */
+  /* else leave the output colorspace as set by options. */
+  if (cinfo->jpeg_color_space == CS_GRAYSCALE)
+    cinfo->out_color_space = CS_GRAYSCALE;
+  else if (cinfo->jpeg_color_space == CS_CMYK)
+    cinfo->out_color_space = CS_CMYK;
+
+  /* select output file format */
+  /* Note: jselwxxx routine may make additional parameter changes,
+   * such as forcing color quantization if it's a colormapped format.
+   */
+  switch (requested_fmt) {
+#ifdef GIF_SUPPORTED
+  case FMT_GIF:
+    jselwgif(cinfo);
+    break;
+#endif
+#ifdef PPM_SUPPORTED
+  case FMT_PPM:
+    jselwppm(cinfo);
+    break;
+#endif
+  default:
+    ERREXIT(cinfo->emethods, "Unsupported output file format");
+    break;
+  }
+}
+
+
+/*
+ * Reload the input buffer after it's been emptied, and return the next byte.
+ * See the JGETC macro for calling conditions.
+ *
+ * This routine would need to be replaced if reading JPEG data from something
+ * other than a stdio stream.
+ */
+
+METHODDEF int
+read_jpeg_data (decompress_info_ptr cinfo)
+{
+  cinfo->bytes_in_buffer = fread(cinfo->input_buffer + MIN_UNGET,
+				 1, JPEG_BUF_SIZE,
+				 cinfo->input_file);
+  
+  cinfo->next_input_byte = cinfo->input_buffer + MIN_UNGET;
+  
+  if (cinfo->bytes_in_buffer <= 0)
+    ERREXIT(cinfo->emethods, "Unexpected EOF in JPEG file");
+
+  return JGETC(cinfo);
+}
+
+
+
+LOCAL void
+usage (char * progname)
+/* complain about bad command line */
+{
+  fprintf(stderr, "usage: %s ", progname);
+  fprintf(stderr, "[-b] [-q colors] [-2] [-d] [-g] [-G]");
+#ifdef TWO_FILE_COMMANDLINE
+  fprintf(stderr, " inputfile outputfile\n");
+#else
+  fprintf(stderr, " [inputfile]\n");
+#endif
+  exit(2);
+}
+
+
+/*
+ * The main program.
+ */
+
+GLOBAL void
+main (int argc, char **argv)
+{
+  struct decompress_info_struct cinfo;
+  struct decompress_methods_struct dc_methods;
+  struct external_methods_struct e_methods;
+  int c;
+
+  /* On Mac, fetch a command line. */
+#ifdef THINK_C
+  argc = ccommand(&argv);
+#endif
+
+  /* Initialize the system-dependent method pointers. */
+  cinfo.methods = &dc_methods;
+  cinfo.emethods = &e_methods;
+  jselerror(&e_methods);	/* error/trace message routines */
+  jselvirtmem(&e_methods);	/* memory allocation routines */
+  dc_methods.d_ui_method_selection = d_ui_method_selection;
+  dc_methods.read_jpeg_data = read_jpeg_data;
+
+  /* Allocate memory for input buffer. */
+  cinfo.input_buffer = (char *) (*cinfo.emethods->alloc_small)
+					((size_t) (JPEG_BUF_SIZE + MIN_UNGET));
+  cinfo.bytes_in_buffer = 0;	/* initialize buffer to empty */
+
+  /* Set up default input and output file references. */
+  /* (These may be overridden below.) */
+  cinfo.input_file = stdin;
+  cinfo.output_file = stdout;
+
+  /* Set up default parameters. */
+  e_methods.trace_level = 0;
+  cinfo.output_gamma = 1.0;
+  cinfo.quantize_colors = FALSE;
+  cinfo.two_pass_quantize = FALSE;
+  cinfo.use_dithering = FALSE;
+  cinfo.desired_number_of_colors = 256;
+  cinfo.do_block_smoothing = FALSE;
+  cinfo.do_pixel_smoothing = FALSE;
+  cinfo.out_color_space = CS_RGB;
+  cinfo.jpeg_color_space = CS_UNKNOWN;
+  /* setting any other value in jpeg_color_space overrides heuristics */
+  /* in jrdjfif.c ... */
+  /* You may wanta change the default output format; here's the place: */
+#ifdef PPM_SUPPORTED
+  requested_fmt = FMT_PPM;
+#else
+  requested_fmt = FMT_GIF;
+#endif
+
+  /* Scan parameters */
+  
+  while ((c = getopt(argc, argv, "bq:2DdgG")) != EOF)
+    switch (c) {
+    case 'b':			/* Enable cross-block smoothing. */
+      cinfo.do_block_smoothing = TRUE;
+      break;
+    case 'q':			/* Do color quantization. */
+      { int val;
+	if (optarg == NULL)
+	  usage(argv[0]);
+	if (sscanf(optarg, "%d", &val) != 1)
+	  usage(argv[0]);
+	cinfo.desired_number_of_colors = val;
+      }
+      cinfo.quantize_colors = TRUE;
+      break;
+    case '2':			/* Use two-pass quantization. */
+      cinfo.two_pass_quantize = TRUE;
+      break;
+    case 'D':			/* Use dithering in color quantization. */
+      cinfo.use_dithering = TRUE;
+      break;
+    case 'd':			/* Debugging. */
+      e_methods.trace_level++;
+      break;
+    case 'g':			/* Force grayscale output. */
+      cinfo.out_color_space = CS_GRAYSCALE;
+      break;
+    case 'G':			/* GIF output format. */
+      requested_fmt = FMT_GIF;
+      break;
+    case '?':
+    default:
+      usage(argv[0]);
+      break;
+    }
+
+  /* Select the input and output files */
+
+#ifdef TWO_FILE_COMMANDLINE
+
+  if (optind != argc-2) {
+    fprintf(stderr, "%s: must name one input and one output file\n", argv[0]);
+    usage(argv[0]);
+  }
+  if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
+    fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
+    exit(2);
+  }
+  if ((cinfo.output_file = fopen(argv[optind+1], WRITE_BINARY)) == NULL) {
+    fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind+1]);
+    exit(2);
+  }
+
+#else /* not TWO_FILE_COMMANDLINE -- use Unix style */
+
+  if (optind < argc-1) {
+    fprintf(stderr, "%s: only one input file\n", argv[0]);
+    usage(argv[0]);
+  }
+  if (optind < argc) {
+    if ((cinfo.input_file = fopen(argv[optind], READ_BINARY)) == NULL) {
+      fprintf(stderr, "%s: can't open %s\n", argv[0], argv[optind]);
+      exit(2);
+    }
+  }
+
+#endif /* TWO_FILE_COMMANDLINE */
+  
+  /* Set up to read a JFIF or baseline-JPEG file. */
+  /* A smarter UI would inspect the first few bytes of the input file */
+  /* to determine its type. */
+#ifdef JFIF_SUPPORTED
+  jselrjfif(&cinfo);
+#else
+  You shoulda defined JFIF_SUPPORTED.   /* deliberate syntax error */
+#endif
+
+  /* Do it to it! */
+  jpeg_decompress(&cinfo);
+
+  /* Release memory. */
+  (*cinfo.emethods->free_small) ((void *) cinfo.input_buffer);
+#ifdef MEM_STATS
+  if (e_methods.trace_level > 0)
+    j_mem_stats();
+#endif
+
+  /* All done. */
+  exit(0);
+}
diff --git a/jdmaster.c b/jdmaster.c
new file mode 100644
index 0000000..5693882
--- /dev/null
+++ b/jdmaster.c
@@ -0,0 +1,180 @@
+/*
+ * jdmaster.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main control for the JPEG decompressor.
+ * The system-dependent (user interface) code should call jpeg_decompress()
+ * after doing appropriate setup of the decompress_info_struct parameter.
+ */
+
+#include "jinclude.h"
+
+
+METHODDEF void
+d_per_scan_method_selection (decompress_info_ptr cinfo)
+/* Central point for per-scan method selection */
+{
+  /* MCU disassembly */
+  jseldmcu(cinfo);
+  /* Un-subsampling of pixels */
+  jselunsubsample(cinfo);
+}
+
+
+LOCAL void
+d_initial_method_selection (decompress_info_ptr cinfo)
+/* Central point for initial method selection (after reading file header) */
+{
+  /* JPEG file scanning method selection is already done. */
+  /* So is output file format selection (both are done by user interface). */
+
+  /* Entropy decoding: either Huffman or arithmetic coding. */
+#ifdef ARITH_CODING_SUPPORTED
+  jseldarithmetic(cinfo);
+#else
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo->emethods, "Arithmetic coding not supported");
+  }
+#endif
+  jseldhuffman(cinfo);
+  /* Cross-block smoothing */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  jselbsmooth(cinfo);
+#else
+  cinfo->do_block_smoothing = FALSE;
+#endif
+  /* Gamma and color space conversion */
+  jseldcolor(cinfo);
+
+  /* Color quantization */
+#ifdef QUANT_1PASS_SUPPORTED
+#ifndef QUANT_2PASS_SUPPORTED
+  cinfo->two_pass_quantize = FALSE; /* only have 1-pass */
+#endif
+#else /* not QUANT_1PASS_SUPPORTED */
+#ifdef QUANT_2PASS_SUPPORTED
+  cinfo->two_pass_quantize = TRUE; /* only have 2-pass */
+#else /* not QUANT_2PASS_SUPPORTED */
+  if (cinfo->quantize_colors) {
+    ERREXIT(cinfo->emethods, "Color quantization was not compiled");
+  }
+#endif
+#endif
+
+#ifdef QUANT_1PASS_SUPPORTED
+  jsel1quantize(cinfo);
+#endif
+#ifdef QUANT_2PASS_SUPPORTED
+  jsel2quantize(cinfo);
+#endif
+
+  /* Pipeline control */
+  jseldpipeline(cinfo);
+  /* Overall control (that's me!) */
+  cinfo->methods->d_per_scan_method_selection = d_per_scan_method_selection;
+}
+
+
+LOCAL void
+initial_setup (decompress_info_ptr cinfo)
+/* Do computations that are needed before initial method selection */
+{
+  short ci;
+  jpeg_component_info *compptr;
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    compptr = &cinfo->comp_info[ci];
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo->emethods, "Bogus sampling factors");
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+
+  }
+
+  /* Compute logical subsampled dimensions of components */
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    compptr = &cinfo->comp_info[ci];
+    compptr->true_comp_width = (cinfo->image_width * compptr->h_samp_factor
+				+ cinfo->max_h_samp_factor - 1)
+				/ cinfo->max_h_samp_factor;
+    compptr->true_comp_height = (cinfo->image_height * compptr->v_samp_factor
+				 + cinfo->max_v_samp_factor - 1)
+				 / cinfo->max_v_samp_factor;
+  }
+}
+
+
+/*
+ * This is the main entry point to the JPEG decompressor.
+ */
+
+
+GLOBAL void
+jpeg_decompress (decompress_info_ptr cinfo)
+{
+  short i;
+
+  /* Initialize pointers as needed to mark stuff unallocated. */
+  cinfo->comp_info = NULL;
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  /* Read the JPEG file header markers; everything up through the first SOS
+   * marker is read now.  NOTE: the user interface must have initialized the
+   * read_file_header method pointer (eg, by calling jselrjfif or jselrtiff).
+   * The other file reading methods (read_scan_header etc.) were probably
+   * set at the same time, but could be set up by read_file_header itself.
+   */
+  (*cinfo->methods->read_file_header) (cinfo);
+  if (! ((*cinfo->methods->read_scan_header) (cinfo)))
+    ERREXIT(cinfo->emethods, "Empty JPEG file");
+
+  /* Give UI a chance to adjust decompression parameters and select */
+  /* output file format based on info from file header. */
+  (*cinfo->methods->d_ui_method_selection) (cinfo);
+
+  /* Now select methods for decompression steps. */
+  initial_setup(cinfo);
+  d_initial_method_selection(cinfo);
+
+  /* Initialize the output file & other modules as needed */
+  /* (color_quant and entropy_decoder are inited by pipeline controller) */
+
+  (*cinfo->methods->output_init) (cinfo);
+  (*cinfo->methods->colorout_init) (cinfo);
+
+  /* And let the pipeline controller do the rest. */
+  (*cinfo->methods->d_pipeline_controller) (cinfo);
+
+  /* Finish output file, release working storage, etc */
+  (*cinfo->methods->colorout_term) (cinfo);
+  (*cinfo->methods->output_term) (cinfo);
+  (*cinfo->methods->read_file_trailer) (cinfo);
+
+  /* Release allocated storage for tables */
+#define FREE(ptr)  if ((ptr) != NULL) \
+			(*cinfo->emethods->free_small) ((void *) ptr)
+
+  FREE(cinfo->comp_info);
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    FREE(cinfo->quant_tbl_ptrs[i]);
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    FREE(cinfo->dc_huff_tbl_ptrs[i]);
+    FREE(cinfo->ac_huff_tbl_ptrs[i]);
+  }
+
+  /* My, that was easy, wasn't it? */
+}
diff --git a/jdmcu.c b/jdmcu.c
new file mode 100644
index 0000000..0d99170
--- /dev/null
+++ b/jdmcu.c
@@ -0,0 +1,146 @@
+/*
+ * jdmcu.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains MCU disassembly routines and quantization descaling.
+ * These routines are invoked via the disassemble_MCU and
+ * disassemble_init/term methods.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * Quantization descaling and zigzag reordering
+ */
+
+
+/* ZAG[i] is the natural-order position of the i'th element of zigzag order. */
+
+static const short ZAG[DCTSIZE2] = {
+  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
+};
+
+
+LOCAL void
+qdescale_zig (JBLOCK input, JBLOCKROW outputptr, QUANT_TBL_PTR quanttbl)
+{
+  short i;
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    (*outputptr)[ZAG[i]] = (*input++) * (*quanttbl++);
+  }
+}
+
+
+
+/*
+ * Fetch one MCU row from entropy_decode, build coefficient array.
+ * This version is used for noninterleaved (single-component) scans.
+ */
+
+METHODDEF void
+disassemble_noninterleaved_MCU (decompress_info_ptr cinfo,
+				JBLOCKIMAGE image_data)
+{
+  JBLOCK MCU_data[1];
+  long mcuindex;
+  jpeg_component_info * compptr;
+  QUANT_TBL_PTR quant_ptr;
+
+  /* this is pretty easy since there is one component and one block per MCU */
+  compptr = cinfo->cur_comp_info[0];
+  quant_ptr = cinfo->quant_tbl_ptrs[compptr->quant_tbl_no];
+  for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
+    /* Fetch the coefficient data */
+    (*cinfo->methods->entropy_decode) (cinfo, MCU_data);
+    /* Descale, reorder, and distribute it into the image array */
+    qdescale_zig(MCU_data[0], image_data[0][0] + mcuindex, quant_ptr);
+  }
+}
+
+
+/*
+ * Fetch one MCU row from entropy_decode, build coefficient array.
+ * This version is used for interleaved (multi-component) scans.
+ */
+
+METHODDEF void
+disassemble_interleaved_MCU (decompress_info_ptr cinfo,
+			     JBLOCKIMAGE image_data)
+{
+  JBLOCK MCU_data[MAX_BLOCKS_IN_MCU];
+  long mcuindex;
+  short blkn, ci, xpos, ypos;
+  jpeg_component_info * compptr;
+  QUANT_TBL_PTR quant_ptr;
+  JBLOCKROW image_ptr;
+
+  for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
+    /* Fetch the coefficient data */
+    (*cinfo->methods->entropy_decode) (cinfo, MCU_data);
+    /* Descale, reorder, and distribute it into the image array */
+    blkn = 0;
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      quant_ptr = cinfo->quant_tbl_ptrs[compptr->quant_tbl_no];
+      for (ypos = 0; ypos < compptr->MCU_height; ypos++) {
+	image_ptr = image_data[ci][ypos] + (mcuindex * compptr->MCU_width);
+	for (xpos = 0; xpos < compptr->MCU_width; xpos++) {
+	  qdescale_zig(MCU_data[blkn], image_ptr, quant_ptr);
+	  image_ptr++;
+	  blkn++;
+	}
+      }
+    }
+  }
+}
+
+
+/*
+ * Initialize for processing a scan.
+ */
+
+METHODDEF void
+disassemble_init (decompress_info_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+/*
+ * Clean up after a scan.
+ */
+
+METHODDEF void
+disassemble_term (decompress_info_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+
+/*
+ * The method selection routine for MCU disassembly.
+ */
+
+GLOBAL void
+jseldmcu (decompress_info_ptr cinfo)
+{
+  if (cinfo->comps_in_scan == 1)
+    cinfo->methods->disassemble_MCU = disassemble_noninterleaved_MCU;
+  else
+    cinfo->methods->disassemble_MCU = disassemble_interleaved_MCU;
+  cinfo->methods->disassemble_init = disassemble_init;
+  cinfo->methods->disassemble_term = disassemble_term;
+}
diff --git a/jdpipe.c b/jdpipe.c
new file mode 100644
index 0000000..8e08874
--- /dev/null
+++ b/jdpipe.c
@@ -0,0 +1,1309 @@
+/*
+ * jdpipe.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains decompression pipeline controllers.
+ * These routines are invoked via the d_pipeline_controller method.
+ *
+ * There are four basic pipeline controllers, one for each combination of:
+ *	single-scan JPEG file (single component or fully interleaved)
+ *  vs. multiple-scan JPEG file (noninterleaved or partially interleaved).
+ *
+ *	2-pass color quantization
+ *  vs. no color quantization or 1-pass quantization.
+ *
+ * Note that these conditions determine the needs for "big" images:
+ * multiple scans imply a big image for recombining the color components;
+ * 2-pass color quantization needs a big image for saving the data for pass 2.
+ *
+ * All but the simplest controller (single-scan, no 2-pass quantization) can be
+ * compiled out through configuration options, if you need to make a minimal
+ * implementation.  You should leave in multiple-scan support if at all
+ * possible, so that you can handle all legal JPEG files.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * About the data structures:
+ *
+ * The processing chunk size for unsubsampling is referred to in this file as
+ * a "row group": a row group is defined as Vk (v_samp_factor) sample rows of
+ * any component while subsampled, or Vmax (max_v_samp_factor) unsubsampled
+ * rows.  In an interleaved scan each MCU row contains exactly DCTSIZE row
+ * groups of each component in the scan.  In a noninterleaved scan an MCU row
+ * is one row of blocks, which might not be an integral number of row groups;
+ * therefore, we read in Vk MCU rows to obtain the same amount of data as we'd
+ * have in an interleaved scan.
+ * To provide context for the unsubsampling step, we have to retain the last
+ * two row groups of the previous MCU row while reading in the next MCU row
+ * (or set of Vk MCU rows).  To do this without copying data about, we create
+ * a rather strange data structure.  Exactly DCTSIZE+2 row groups of samples
+ * are allocated, but we create two different sets of pointers to this array.
+ * The second set swaps the last two pairs of row groups.  By working
+ * alternately with the two sets of pointers, we can access the data in the
+ * desired order.
+ *
+ * Cross-block smoothing also needs context above and below the "current" row.
+ * Since this is an optional feature, I've implemented it in a way that is
+ * much simpler but requires more than the minimum amount of memory.  We
+ * simply allocate three extra MCU rows worth of coefficient blocks and use
+ * them to "read ahead" one MCU row in the file.  For a typical 1000-pixel-wide
+ * image with 2x2,1x1,1x1 sampling, each MCU row is about 50Kb; an 80x86
+ * machine may be unable to apply cross-block smoothing to wider images.
+ */
+
+
+/*
+ * These variables are logically local to the pipeline controller,
+ * but we make them static so that scan_big_image can use them
+ * without having to pass them through the quantization routines.
+ * If you don't support 2-pass quantization, you could make them locals.
+ */
+
+static int rows_in_mem;		/* # of sample rows in full-size buffers */
+/* Full-size image array holding desubsampled, color-converted data. */
+static big_sarray_ptr *fullsize_cnvt_image;
+static JSAMPIMAGE fullsize_cnvt_ptrs; /* workspace for access_big_sarray() results */
+/* Work buffer for color quantization output (full size, only 1 component). */
+static JSAMPARRAY quantize_out;
+
+
+/*
+ * Utility routines: common code for pipeline controllers
+ */
+
+LOCAL void
+interleaved_scan_setup (decompress_info_ptr cinfo)
+/* Compute all derived info for an interleaved (multi-component) scan */
+/* On entry, cinfo->comps_in_scan and cinfo->cur_comp_info[] are set up */
+{
+  short ci, mcublks;
+  jpeg_component_info *compptr;
+
+  if (cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo->emethods, "Too many components for interleaved scan");
+
+  cinfo->MCUs_per_row = (cinfo->image_width
+			 + cinfo->max_h_samp_factor*DCTSIZE - 1)
+			/ (cinfo->max_h_samp_factor*DCTSIZE);
+
+  cinfo->MCU_rows_in_scan = (cinfo->image_height
+			     + cinfo->max_v_samp_factor*DCTSIZE - 1)
+			    / (cinfo->max_v_samp_factor*DCTSIZE);
+  
+  cinfo->blocks_in_MCU = 0;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* for interleaved scan, sampling factors give # of blocks per component */
+    compptr->MCU_width = compptr->h_samp_factor;
+    compptr->MCU_height = compptr->v_samp_factor;
+    compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+    /* compute physical dimensions of component */
+    compptr->subsampled_width = jround_up(compptr->true_comp_width,
+					  (long) (compptr->MCU_width*DCTSIZE));
+    compptr->subsampled_height = jround_up(compptr->true_comp_height,
+					   (long) (compptr->MCU_height*DCTSIZE));
+    /* Sanity check */
+    if (compptr->subsampled_width !=
+	(cinfo->MCUs_per_row * (compptr->MCU_width*DCTSIZE)))
+      ERREXIT(cinfo->emethods, "I'm confused about the image width");
+    /* Prepare array describing MCU composition */
+    mcublks = compptr->MCU_blocks;
+    if (cinfo->blocks_in_MCU + mcublks > MAX_BLOCKS_IN_MCU)
+      ERREXIT(cinfo->emethods, "Sampling factors too large for interleaved scan");
+    while (mcublks-- > 0) {
+      cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+    }
+  }
+
+  (*cinfo->methods->d_per_scan_method_selection) (cinfo);
+}
+
+
+LOCAL void
+noninterleaved_scan_setup (decompress_info_ptr cinfo)
+/* Compute all derived info for a noninterleaved (single-component) scan */
+/* On entry, cinfo->comps_in_scan = 1 and cinfo->cur_comp_info[0] is set up */
+{
+  jpeg_component_info *compptr = cinfo->cur_comp_info[0];
+
+  /* for noninterleaved scan, always one block per MCU */
+  compptr->MCU_width = 1;
+  compptr->MCU_height = 1;
+  compptr->MCU_blocks = 1;
+  /* compute physical dimensions of component */
+  compptr->subsampled_width = jround_up(compptr->true_comp_width,
+					(long) DCTSIZE);
+  compptr->subsampled_height = jround_up(compptr->true_comp_height,
+					 (long) DCTSIZE);
+
+  cinfo->MCUs_per_row = compptr->subsampled_width / DCTSIZE;
+  cinfo->MCU_rows_in_scan = compptr->subsampled_height / DCTSIZE;
+
+  /* Prepare array describing MCU composition */
+  cinfo->blocks_in_MCU = 1;
+  cinfo->MCU_membership[0] = 0;
+
+  (*cinfo->methods->d_per_scan_method_selection) (cinfo);
+}
+
+
+LOCAL void
+reverse_DCT (decompress_info_ptr cinfo,
+	     JBLOCKIMAGE coeff_data, JSAMPIMAGE output_data,
+	     int start_row)
+/* Perform inverse DCT on each block in an MCU row's worth of data; */
+/* output the results into a sample array starting at row start_row. */
+/* NB: start_row can only be nonzero when dealing with a single-component */
+/* scan; otherwise we'd have to provide for different offsets for different */
+/* components, since the heights of interleaved MCU rows can vary. */
+{
+  DCTBLOCK block;
+  JBLOCKROW browptr;
+  JSAMPARRAY srowptr;
+  long blocksperrow, bi;
+  short numrows, ri;
+  short ci;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    /* calc size of an MCU row in this component */
+    blocksperrow = cinfo->cur_comp_info[ci]->subsampled_width / DCTSIZE;
+    numrows = cinfo->cur_comp_info[ci]->MCU_height;
+    /* iterate through all blocks in MCU row */
+    for (ri = 0; ri < numrows; ri++) {
+      browptr = coeff_data[ci][ri];
+      srowptr = output_data[ci] + (ri * DCTSIZE + start_row);
+      for (bi = 0; bi < blocksperrow; bi++) {
+	/* copy the data into a local DCTBLOCK.  This allows for change of
+	 * representation (if DCTELEM != JCOEF).  On 80x86 machines it also
+	 * brings the data back from FAR storage to NEAR storage.
+	 */
+	{ register JCOEFPTR elemptr = browptr[bi];
+	  register DCTELEM *localblkptr = block;
+	  register short elem = DCTSIZE2;
+
+	  while (--elem >= 0)
+	    *localblkptr++ = (DCTELEM) *elemptr++;
+	}
+
+	j_rev_dct(block);	/* perform inverse DCT */
+
+	/* output the data into the sample array.
+	 * Note change from signed to unsigned representation:
+	 * DCT calculation works with values +-CENTERJSAMPLE,
+	 * but sample arrays always hold 0..MAXJSAMPLE.
+	 * Have to do explicit range-limiting because of quantization errors
+	 * and so forth in the DCT/IDCT phase.
+	 */
+	{ register JSAMPROW elemptr;
+	  register DCTELEM *localblkptr = block;
+	  register short elemr, elemc;
+	  register DCTELEM temp;
+
+	  for (elemr = 0; elemr < DCTSIZE; elemr++) {
+	    elemptr = srowptr[elemr] + (bi * DCTSIZE);
+	    for (elemc = 0; elemc < DCTSIZE; elemc++) {
+	      temp = (*localblkptr++) + CENTERJSAMPLE;
+	      if (temp < 0) temp = 0;
+	      else if (temp > MAXJSAMPLE) temp = MAXJSAMPLE;
+	      *elemptr++ = (JSAMPLE) temp;
+	    }
+	  }
+	}
+      }
+    }
+  }
+}
+
+
+
+LOCAL JSAMPIMAGE
+alloc_sampimage (decompress_info_ptr cinfo,
+		 int num_comps, long num_rows, long num_cols)
+/* Allocate an in-memory sample image (all components same size) */
+{
+  JSAMPIMAGE image;
+  int ci;
+
+  image = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(num_comps * SIZEOF(JSAMPARRAY));
+  for (ci = 0; ci < num_comps; ci++) {
+    image[ci] = (*cinfo->emethods->alloc_small_sarray) (num_cols, num_rows);
+  }
+  return image;
+}
+
+
+LOCAL void
+free_sampimage (decompress_info_ptr cinfo, JSAMPIMAGE image,
+		int num_comps, long num_rows)
+/* Release a sample image created by alloc_sampimage */
+{
+  int ci;
+
+  for (ci = 0; ci < num_comps; ci++) {
+      (*cinfo->emethods->free_small_sarray) (image[ci], num_rows);
+  }
+  (*cinfo->emethods->free_small) ((void *) image);
+}
+
+
+LOCAL JBLOCKIMAGE
+alloc_MCU_row (decompress_info_ptr cinfo)
+/* Allocate one MCU row's worth of coefficient blocks */
+{
+  JBLOCKIMAGE image;
+  int ci;
+
+  image = (JBLOCKIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->comps_in_scan * SIZEOF(JBLOCKARRAY));
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    image[ci] = (*cinfo->emethods->alloc_small_barray)
+			(cinfo->cur_comp_info[ci]->subsampled_width / DCTSIZE,
+			 (long) cinfo->cur_comp_info[ci]->MCU_height);
+  }
+  return image;
+}
+
+
+LOCAL void
+free_MCU_row (decompress_info_ptr cinfo, JBLOCKIMAGE image)
+/* Release a coefficient block array created by alloc_MCU_row */
+{
+  int ci;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    (*cinfo->emethods->free_small_barray)
+		(image[ci], (long) cinfo->cur_comp_info[ci]->MCU_height);
+  }
+  (*cinfo->emethods->free_small) ((void *) image);
+}
+
+
+LOCAL void
+alloc_sampling_buffer (decompress_info_ptr cinfo, JSAMPIMAGE subsampled_data[2])
+/* Create a subsampled-data buffer having the desired structure */
+/* (see comments at head of file) */
+{
+  short ci, vs, i;
+
+  /* Get top-level space for array pointers */
+  subsampled_data[0] = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->comps_in_scan * SIZEOF(JSAMPARRAY));
+  subsampled_data[1] = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->comps_in_scan * SIZEOF(JSAMPARRAY));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    vs = cinfo->cur_comp_info[ci]->v_samp_factor; /* row group height */
+    /* Allocate the real storage */
+    subsampled_data[0][ci] = (*cinfo->emethods->alloc_small_sarray)
+				(cinfo->cur_comp_info[ci]->subsampled_width,
+				(long) (vs * (DCTSIZE+2)));
+    /* Create space for the scrambled-order pointers */
+    subsampled_data[1][ci] = (JSAMPARRAY) (*cinfo->emethods->alloc_small)
+				(vs * (DCTSIZE+2) * SIZEOF(JSAMPROW));
+    /* Duplicate the first DCTSIZE-2 row groups */
+    for (i = 0; i < vs * (DCTSIZE-2); i++) {
+      subsampled_data[1][ci][i] = subsampled_data[0][ci][i];
+    }
+    /* Copy the last four row groups in swapped order */
+    for (i = 0; i < vs * 2; i++) {
+      subsampled_data[1][ci][vs*DCTSIZE + i] = subsampled_data[0][ci][vs*(DCTSIZE-2) + i];
+      subsampled_data[1][ci][vs*(DCTSIZE-2) + i] = subsampled_data[0][ci][vs*DCTSIZE + i];
+    }
+  }
+}
+
+
+LOCAL void
+free_sampling_buffer (decompress_info_ptr cinfo, JSAMPIMAGE subsampled_data[2])
+/* Release a sampling buffer created by alloc_sampling_buffer */
+{
+  short ci, vs;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    vs = cinfo->cur_comp_info[ci]->v_samp_factor; /* row group height */
+    /* Free the real storage */
+    (*cinfo->emethods->free_small_sarray)
+		(subsampled_data[0][ci], (long) (vs * (DCTSIZE+2)));
+    /* Free the scrambled-order pointers */
+    (*cinfo->emethods->free_small) ((void *) subsampled_data[1][ci]);
+  }
+
+  /* Free the top-level space */
+  (*cinfo->emethods->free_small) ((void *) subsampled_data[0]);
+  (*cinfo->emethods->free_small) ((void *) subsampled_data[1]);
+}
+
+
+LOCAL void
+duplicate_row (JSAMPARRAY image_data,
+	       long num_cols, int source_row, int num_rows)
+/* Duplicate the source_row at source_row+1 .. source_row+num_rows */
+/* This happens only at the bottom of the image, */
+/* so it needn't be super-efficient */
+{
+  register int row;
+
+  for (row = 1; row <= num_rows; row++) {
+    jcopy_sample_rows(image_data, source_row, image_data, source_row + row,
+		      1, num_cols);
+  }
+}
+
+
+LOCAL void
+expand (decompress_info_ptr cinfo,
+	JSAMPIMAGE subsampled_data, JSAMPIMAGE fullsize_data,
+	long fullsize_width,
+	short above, short current, short below, short out)
+/* Do unsubsampling expansion of a single row group (of each component).  */
+/* above, current, below are indexes of row groups in subsampled_data;    */
+/* out is the index of the target row group in fullsize_data.             */
+/* Special case: above, below can be -1 to indicate top, bottom of image. */
+{
+  jpeg_component_info *compptr;
+  JSAMPARRAY above_ptr, below_ptr;
+  JSAMPROW dummy[MAX_SAMP_FACTOR]; /* for subsample expansion at top/bottom */
+  short ci, vs, i;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    vs = compptr->v_samp_factor; /* row group height */
+
+    if (above >= 0)
+      above_ptr = subsampled_data[ci] + above * vs;
+    else {
+      /* Top of image: make a dummy above-context with copies of 1st row */
+      /* We assume current=0 in this case */
+      for (i = 0; i < vs; i++)
+	dummy[i] = subsampled_data[ci][0];
+      above_ptr = (JSAMPARRAY) dummy; /* possible near->far pointer conv */
+    }
+
+    if (below >= 0)
+      below_ptr = subsampled_data[ci] + below * vs;
+    else {
+      /* Bot of image: make a dummy below-context with copies of last row */
+      for (i = 0; i < vs; i++)
+	dummy[i] = subsampled_data[ci][(current+1)*vs-1];
+      below_ptr = (JSAMPARRAY) dummy; /* possible near->far pointer conv */
+    }
+
+    (*cinfo->methods->unsubsample[ci])
+		(cinfo, (int) ci,
+		 compptr->subsampled_width, (int) vs,
+		 fullsize_width, (int) cinfo->max_v_samp_factor,
+		 above_ptr,
+		 subsampled_data[ci] + current * vs,
+		 below_ptr,
+		 fullsize_data[ci] + out * cinfo->max_v_samp_factor);
+  }
+}
+
+
+LOCAL void
+emit_1pass (decompress_info_ptr cinfo, int num_rows,
+	    JSAMPIMAGE fullsize_data, JSAMPIMAGE color_data)
+/* Do color conversion and output of num_rows full-size rows. */
+/* This is not used for 2-pass color quantization. */
+{
+  (*cinfo->methods->color_convert) (cinfo, num_rows,
+				    fullsize_data, color_data);
+
+  if (cinfo->quantize_colors) {
+    (*cinfo->methods->color_quantize) (cinfo, num_rows,
+				       color_data, quantize_out);
+
+    (*cinfo->methods->put_pixel_rows) (cinfo, num_rows,
+				       &quantize_out);
+  } else {
+    (*cinfo->methods->put_pixel_rows) (cinfo, num_rows,
+				       color_data);
+  }
+}
+
+
+/*
+ * Support routines for 2-pass color quantization.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+LOCAL void
+emit_2pass (decompress_info_ptr cinfo, long top_row, int num_rows,
+	    JSAMPIMAGE fullsize_data)
+/* Do color conversion and output data to the quantization buffer image. */
+/* This is used only with 2-pass color quantization. */
+{
+  short ci;
+
+  /* Realign the big buffers */
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    fullsize_cnvt_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
+      (fullsize_cnvt_image[ci], top_row, TRUE);
+  }
+
+  /* Do colorspace conversion */
+  (*cinfo->methods->color_convert) (cinfo, num_rows,
+				    fullsize_data, fullsize_cnvt_ptrs);
+  /* Let quantizer get first-pass peek at the data. */
+  /* (Quantizer could change data if it wants to.)  */
+  (*cinfo->methods->color_quant_prescan) (cinfo, num_rows, fullsize_cnvt_ptrs);
+}
+
+
+METHODDEF void
+scan_big_image (decompress_info_ptr cinfo, quantize_method_ptr quantize_method)
+/* This is the "iterator" routine used by the quantizer. */
+{
+  long pixel_rows_output;
+  short ci;
+
+  for (pixel_rows_output = 0; pixel_rows_output < cinfo->image_height;
+       pixel_rows_output += rows_in_mem) {
+    /* Realign the big buffers */
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      fullsize_cnvt_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
+	(fullsize_cnvt_image[ci], pixel_rows_output, FALSE);
+    }
+    /* Let the quantizer have its way with the data.
+     * Note that quantize_out is simply workspace for the quantizer;
+     * when it's ready to output, it must call put_pixel_rows itself.
+     */
+    (*quantize_method) (cinfo,
+			(int) MIN(rows_in_mem,
+				  cinfo->image_height - pixel_rows_output),
+			fullsize_cnvt_ptrs, quantize_out);
+  }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Support routines for cross-block smoothing.
+ */
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+
+LOCAL void
+smooth_mcu_row (decompress_info_ptr cinfo,
+		JBLOCKIMAGE above, JBLOCKIMAGE input, JBLOCKIMAGE below,
+		JBLOCKIMAGE output)
+/* Apply cross-block smoothing to one MCU row's worth of coefficient blocks. */
+/* above,below are NULL if at top/bottom of image. */
+{
+  jpeg_component_info *compptr;
+  short ci, ri, last;
+  JBLOCKROW prev;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    last = compptr->MCU_height - 1;
+
+    if (above == NULL)
+      prev = NULL;
+    else
+      prev = above[ci][last];
+
+    for (ri = 0; ri < last; ri++) {
+      (*cinfo->methods->smooth_coefficients) (cinfo, compptr,
+				prev, input[ci][ri], input[ci][ri+1],
+				output[ci][ri]);
+      prev = input[ci][ri];
+    }
+
+    if (below == NULL)
+      (*cinfo->methods->smooth_coefficients) (cinfo, compptr,
+				prev, input[ci][last], (JBLOCKROW) NULL,
+				output[ci][last]);
+    else
+      (*cinfo->methods->smooth_coefficients) (cinfo, compptr,
+				prev, input[ci][last], below[ci][0],
+				output[ci][last]);
+  }
+}
+
+
+LOCAL void
+get_smoothed_row (decompress_info_ptr cinfo, JBLOCKIMAGE coeff_data,
+		  JBLOCKIMAGE bsmooth[3], int * whichb, long cur_mcu_row)
+/* Get an MCU row of coefficients, applying cross-block smoothing. */
+/* The output row is placed in coeff_data.  bsmooth and whichb hold */
+/* working state, and cur_row is needed to check for image top/bottom. */
+/* This routine just takes care of the buffering logic. */
+{
+  int prev, cur, next;
+  
+  /* Special case for top of image: need to pre-fetch a row & init whichb */
+  if (cur_mcu_row == 0) {
+    (*cinfo->methods->disassemble_MCU) (cinfo, bsmooth[0]);
+    if (cinfo->MCU_rows_in_scan > 1) {
+      (*cinfo->methods->disassemble_MCU) (cinfo, bsmooth[1]);
+      smooth_mcu_row(cinfo, (JBLOCKIMAGE) NULL, bsmooth[0], bsmooth[1],
+		     coeff_data);
+    } else {
+      smooth_mcu_row(cinfo, (JBLOCKIMAGE) NULL, bsmooth[0], (JBLOCKIMAGE) NULL,
+		     coeff_data);
+    }
+    *whichb = 1;		/* points to next bsmooth[] element to use */
+    return;
+  }
+  
+  cur = *whichb;		/* set up references */
+  prev = (cur == 0 ? 2 : cur - 1);
+  next = (cur == 2 ? 0 : cur + 1);
+  *whichb = next;		/* advance whichb for next time */
+  
+  /* Special case for bottom of image: don't read another row */
+  if (cur_mcu_row >= cinfo->MCU_rows_in_scan - 1) {
+    smooth_mcu_row(cinfo, bsmooth[prev], bsmooth[cur], (JBLOCKIMAGE) NULL,
+		   coeff_data);
+    return;
+  }
+  
+  /* Normal case: read ahead a new row, smooth the one I got before */
+  (*cinfo->methods->disassemble_MCU) (cinfo, bsmooth[next]);
+  smooth_mcu_row(cinfo, bsmooth[prev], bsmooth[cur], bsmooth[next],
+		 coeff_data);
+}
+
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
+
+
+
+/*
+ * Decompression pipeline controller used for single-scan files
+ * without 2-pass color quantization.
+ */
+
+METHODDEF void
+single_dcontroller (decompress_info_ptr cinfo)
+{
+  long fullsize_width;		/* # of samples per row in full-size buffers */
+  long cur_mcu_row;		/* counts # of MCU rows processed */
+  long pixel_rows_output;	/* # of pixel rows actually emitted */
+  int mcu_rows_per_loop;	/* # of MCU rows processed per outer loop */
+  /* Work buffer for dequantized coefficients (IDCT input) */
+  JBLOCKIMAGE coeff_data;
+  /* Work buffer for cross-block smoothing input */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  JBLOCKIMAGE bsmooth[3];	/* this is optional */
+  int whichb;
+#endif
+  /* Work buffer for subsampled image data (see comments at head of file) */
+  JSAMPIMAGE subsampled_data[2];
+  /* Work buffer for desubsampled data */
+  JSAMPIMAGE fullsize_data;
+  /* Work buffer for color conversion output (full size) */
+  JSAMPIMAGE color_data;
+  int whichss, ri;
+  short i;
+
+  /* Initialize for 1-pass color quantization, if needed */
+  if (cinfo->quantize_colors)
+    (*cinfo->methods->color_quant_init) (cinfo);
+
+  /* Prepare for single scan containing all components */
+  if (cinfo->comps_in_scan == 1) {
+    noninterleaved_scan_setup(cinfo);
+    /* Need to read Vk MCU rows to obtain Vk block rows */
+    mcu_rows_per_loop = cinfo->cur_comp_info[0]->v_samp_factor;
+  } else {
+    interleaved_scan_setup(cinfo);
+    /* in an interleaved scan, one MCU row provides Vk block rows */
+    mcu_rows_per_loop = 1;
+  }
+
+  /* Compute dimensions of full-size pixel buffers */
+  /* Note these are the same whether interleaved or not. */
+  rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
+  fullsize_width = jround_up(cinfo->image_width,
+			     (long) (cinfo->max_h_samp_factor * DCTSIZE));
+
+  /* Allocate working memory: */
+  /* coeff_data holds a single MCU row of coefficient blocks */
+  coeff_data = alloc_MCU_row(cinfo);
+  /* if doing cross-block smoothing, need extra space for its input */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  if (cinfo->do_block_smoothing) {
+    bsmooth[0] = alloc_MCU_row(cinfo);
+    bsmooth[1] = alloc_MCU_row(cinfo);
+    bsmooth[2] = alloc_MCU_row(cinfo);
+  }
+#endif
+  /* subsampled_data is sample data before unsubsampling */
+  alloc_sampling_buffer(cinfo, subsampled_data);
+  /* fullsize_data is sample data after unsubsampling */
+  fullsize_data = alloc_sampimage(cinfo, (int) cinfo->num_components,
+				  (long) rows_in_mem, fullsize_width);
+  /* color_data is the result of the colorspace conversion step */
+  color_data = alloc_sampimage(cinfo, (int) cinfo->color_out_comps,
+			       (long) rows_in_mem, fullsize_width);
+  /* if quantizing colors, also need a one-component output area for that. */
+  if (cinfo->quantize_colors)
+    quantize_out = (*cinfo->emethods->alloc_small_sarray)
+				(fullsize_width, (long) rows_in_mem);
+
+  /* Tell the memory manager to instantiate big arrays.
+   * We don't need any big arrays in this controller,
+   * but some other module (like the output file writer) may need one.
+   */
+  (*cinfo->emethods->alloc_big_arrays)
+	((long) 0,				/* no more small sarrays */
+	 (long) 0,				/* no more small barrays */
+	 (long) 0);				/* no more "medium" objects */
+	 /* NB: quantizer must get any such objects at color_quant_init time */
+
+  /* Initialize to read scan data */
+
+  (*cinfo->methods->entropy_decoder_init) (cinfo);
+  (*cinfo->methods->unsubsample_init) (cinfo);
+  (*cinfo->methods->disassemble_init) (cinfo);
+
+  /* Loop over scan's data: rows_in_mem pixel rows are processed per loop */
+
+  pixel_rows_output = 0;
+  whichss = 1;			/* arrange to start with subsampled_data[0] */
+
+  for (cur_mcu_row = 0; cur_mcu_row < cinfo->MCU_rows_in_scan;
+       cur_mcu_row += mcu_rows_per_loop) {
+    whichss ^= 1;		/* switch to other subsample buffer */
+
+    /* Obtain v_samp_factor block rows of each component in the scan. */
+    /* This is a single MCU row if interleaved, multiple MCU rows if not. */
+    /* In the noninterleaved case there might be fewer than v_samp_factor */
+    /* block rows remaining; if so, pad with copies of the last pixel row */
+    /* so that unsubsampling doesn't have to treat it as a special case. */
+
+    for (ri = 0; ri < mcu_rows_per_loop; ri++) {
+      if (cur_mcu_row + ri < cinfo->MCU_rows_in_scan) {
+	/* OK to actually read an MCU row. */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+	if (cinfo->do_block_smoothing)
+	  get_smoothed_row(cinfo, coeff_data,
+			   bsmooth, &whichb, cur_mcu_row + ri);
+	else
+#endif
+	  (*cinfo->methods->disassemble_MCU) (cinfo, coeff_data);
+      
+	reverse_DCT(cinfo, coeff_data, subsampled_data[whichss],
+		    ri * DCTSIZE);
+      } else {
+	/* Need to pad out with copies of the last subsampled row. */
+	/* This can only happen if there is just one component. */
+	duplicate_row(subsampled_data[whichss][0],
+		      cinfo->cur_comp_info[0]->subsampled_width,
+		      ri * DCTSIZE - 1, DCTSIZE);
+      }
+    }
+
+    /* Unsubsample the data */
+    /* First time through is a special case */
+
+    if (cur_mcu_row) {
+      /* Expand last row group of previous set */
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
+	     (short) (DCTSIZE-1));
+      /* and dump the previous set's expanded data */
+      emit_1pass (cinfo, rows_in_mem, fullsize_data, color_data);
+      pixel_rows_output += rows_in_mem;
+      /* Expand first row group of this set */
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) (DCTSIZE+1), (short) 0, (short) 1,
+	     (short) 0);
+    } else {
+      /* Expand first row group with dummy above-context */
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) (-1), (short) 0, (short) 1,
+	     (short) 0);
+    }
+    /* Expand second through next-to-last row groups of this set */
+    for (i = 1; i <= DCTSIZE-2; i++) {
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) (i-1), (short) i, (short) (i+1),
+	     (short) i);
+    }
+  } /* end of outer loop */
+
+  /* Expand the last row group with dummy below-context */
+  /* Note whichss points to last buffer side used */
+  expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	 (short) (DCTSIZE-2), (short) (DCTSIZE-1), (short) (-1),
+	 (short) (DCTSIZE-1));
+  /* and dump the remaining data (may be less than full height) */
+  emit_1pass (cinfo, (int) (cinfo->image_height - pixel_rows_output),
+	      fullsize_data, color_data);
+
+  /* Clean up after the scan */
+  (*cinfo->methods->disassemble_term) (cinfo);
+  (*cinfo->methods->unsubsample_term) (cinfo);
+  (*cinfo->methods->entropy_decoder_term) (cinfo);
+  (*cinfo->methods->read_scan_trailer) (cinfo);
+
+  /* Verify that we've seen the whole input file */
+  if ((*cinfo->methods->read_scan_header) (cinfo))
+    ERREXIT(cinfo->emethods, "Didn't expect more than one scan");
+
+  /* Release working memory */
+  free_MCU_row(cinfo, coeff_data);
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  if (cinfo->do_block_smoothing) {
+    free_MCU_row(cinfo, bsmooth[0]);
+    free_MCU_row(cinfo, bsmooth[1]);
+    free_MCU_row(cinfo, bsmooth[2]);
+  }
+#endif
+  free_sampling_buffer(cinfo, subsampled_data);
+  free_sampimage(cinfo, fullsize_data, (int) cinfo->num_components,
+		 (long) rows_in_mem);
+  free_sampimage(cinfo, color_data, (int) cinfo->color_out_comps,
+		 (long) rows_in_mem);
+  if (cinfo->quantize_colors)
+    (*cinfo->emethods->free_small_sarray)
+		(quantize_out, (long) rows_in_mem);
+
+  /* Close up shop */
+  if (cinfo->quantize_colors)
+    (*cinfo->methods->color_quant_term) (cinfo);
+}
+
+
+/*
+ * Decompression pipeline controller used for single-scan files
+ * with 2-pass color quantization.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF void
+single_2quant_dcontroller (decompress_info_ptr cinfo)
+{
+  long fullsize_width;		/* # of samples per row in full-size buffers */
+  long cur_mcu_row;		/* counts # of MCU rows processed */
+  long pixel_rows_output;	/* # of pixel rows actually emitted */
+  int mcu_rows_per_loop;	/* # of MCU rows processed per outer loop */
+  /* Work buffer for dequantized coefficients (IDCT input) */
+  JBLOCKIMAGE coeff_data;
+  /* Work buffer for cross-block smoothing input */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  JBLOCKIMAGE bsmooth[3];	/* this is optional */
+  int whichb;
+#endif
+  /* Work buffer for subsampled image data (see comments at head of file) */
+  JSAMPIMAGE subsampled_data[2];
+  /* Work buffer for desubsampled data */
+  JSAMPIMAGE fullsize_data;
+  int whichss, ri;
+  short ci, i;
+
+  /* Initialize for 2-pass color quantization */
+  (*cinfo->methods->color_quant_init) (cinfo);
+
+  /* Prepare for single scan containing all components */
+  if (cinfo->comps_in_scan == 1) {
+    noninterleaved_scan_setup(cinfo);
+    /* Need to read Vk MCU rows to obtain Vk block rows */
+    mcu_rows_per_loop = cinfo->cur_comp_info[0]->v_samp_factor;
+  } else {
+    interleaved_scan_setup(cinfo);
+    /* in an interleaved scan, one MCU row provides Vk block rows */
+    mcu_rows_per_loop = 1;
+  }
+
+  /* Compute dimensions of full-size pixel buffers */
+  /* Note these are the same whether interleaved or not. */
+  rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
+  fullsize_width = jround_up(cinfo->image_width,
+			     (long) (cinfo->max_h_samp_factor * DCTSIZE));
+
+  /* Allocate working memory: */
+  /* coeff_data holds a single MCU row of coefficient blocks */
+  coeff_data = alloc_MCU_row(cinfo);
+  /* if doing cross-block smoothing, need extra space for its input */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  if (cinfo->do_block_smoothing) {
+    bsmooth[0] = alloc_MCU_row(cinfo);
+    bsmooth[1] = alloc_MCU_row(cinfo);
+    bsmooth[2] = alloc_MCU_row(cinfo);
+  }
+#endif
+  /* subsampled_data is sample data before unsubsampling */
+  alloc_sampling_buffer(cinfo, subsampled_data);
+  /* fullsize_data is sample data after unsubsampling */
+  fullsize_data = alloc_sampimage(cinfo, (int) cinfo->num_components,
+				  (long) rows_in_mem, fullsize_width);
+  /* Also need a one-component output area for color quantizer. */
+  quantize_out = (*cinfo->emethods->alloc_small_sarray)
+				(fullsize_width, (long) rows_in_mem);
+
+  /* Get a big image for quantizer input: desubsampled, color-converted data */
+  fullsize_cnvt_image = (big_sarray_ptr *) (*cinfo->emethods->alloc_small)
+			(cinfo->num_components * SIZEOF(big_sarray_ptr));
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    fullsize_cnvt_image[ci] = (*cinfo->emethods->request_big_sarray)
+			(fullsize_width,
+			 jround_up(cinfo->image_height, (long) rows_in_mem),
+			 (long) rows_in_mem);
+  }
+  /* Also get an area for pointers to currently accessible chunks */
+  fullsize_cnvt_ptrs = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->num_components * SIZEOF(JSAMPARRAY));
+
+  /* Tell the memory manager to instantiate big arrays */
+  (*cinfo->emethods->alloc_big_arrays)
+	((long) 0,				/* no more small sarrays */
+	 (long) 0,				/* no more small barrays */
+	 (long) 0);				/* no more "medium" objects */
+	 /* NB: quantizer must get any such objects at color_quant_init time */
+
+  /* Initialize to read scan data */
+
+  (*cinfo->methods->entropy_decoder_init) (cinfo);
+  (*cinfo->methods->unsubsample_init) (cinfo);
+  (*cinfo->methods->disassemble_init) (cinfo);
+
+  /* Loop over scan's data: rows_in_mem pixel rows are processed per loop */
+
+  pixel_rows_output = 0;
+  whichss = 1;			/* arrange to start with subsampled_data[0] */
+
+  for (cur_mcu_row = 0; cur_mcu_row < cinfo->MCU_rows_in_scan;
+       cur_mcu_row += mcu_rows_per_loop) {
+    whichss ^= 1;		/* switch to other subsample buffer */
+
+    /* Obtain v_samp_factor block rows of each component in the scan. */
+    /* This is a single MCU row if interleaved, multiple MCU rows if not. */
+    /* In the noninterleaved case there might be fewer than v_samp_factor */
+    /* block rows remaining; if so, pad with copies of the last pixel row */
+    /* so that unsubsampling doesn't have to treat it as a special case. */
+
+    for (ri = 0; ri < mcu_rows_per_loop; ri++) {
+      if (cur_mcu_row + ri < cinfo->MCU_rows_in_scan) {
+	/* OK to actually read an MCU row. */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+	if (cinfo->do_block_smoothing)
+	  get_smoothed_row(cinfo, coeff_data,
+			   bsmooth, &whichb, cur_mcu_row + ri);
+	else
+#endif
+	  (*cinfo->methods->disassemble_MCU) (cinfo, coeff_data);
+      
+	reverse_DCT(cinfo, coeff_data, subsampled_data[whichss],
+		    ri * DCTSIZE);
+      } else {
+	/* Need to pad out with copies of the last subsampled row. */
+	/* This can only happen if there is just one component. */
+	duplicate_row(subsampled_data[whichss][0],
+		      cinfo->cur_comp_info[0]->subsampled_width,
+		      ri * DCTSIZE - 1, DCTSIZE);
+      }
+    }
+
+    /* Unsubsample the data */
+    /* First time through is a special case */
+
+    if (cur_mcu_row) {
+      /* Expand last row group of previous set */
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
+	     (short) (DCTSIZE-1));
+      /* and dump the previous set's expanded data */
+      emit_2pass (cinfo, pixel_rows_output, rows_in_mem, fullsize_data);
+      pixel_rows_output += rows_in_mem;
+      /* Expand first row group of this set */
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) (DCTSIZE+1), (short) 0, (short) 1,
+	     (short) 0);
+    } else {
+      /* Expand first row group with dummy above-context */
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) (-1), (short) 0, (short) 1,
+	     (short) 0);
+    }
+    /* Expand second through next-to-last row groups of this set */
+    for (i = 1; i <= DCTSIZE-2; i++) {
+      expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	     (short) (i-1), (short) i, (short) (i+1),
+	     (short) i);
+    }
+  } /* end of outer loop */
+
+  /* Expand the last row group with dummy below-context */
+  /* Note whichss points to last buffer side used */
+  expand(cinfo, subsampled_data[whichss], fullsize_data, fullsize_width,
+	 (short) (DCTSIZE-2), (short) (DCTSIZE-1), (short) (-1),
+	 (short) (DCTSIZE-1));
+  /* and dump the remaining data (may be less than full height) */
+  emit_2pass (cinfo, pixel_rows_output,
+	      (int) (cinfo->image_height - pixel_rows_output),
+	      fullsize_data);
+
+  /* Clean up after the scan */
+  (*cinfo->methods->disassemble_term) (cinfo);
+  (*cinfo->methods->unsubsample_term) (cinfo);
+  (*cinfo->methods->entropy_decoder_term) (cinfo);
+  (*cinfo->methods->read_scan_trailer) (cinfo);
+
+  /* Verify that we've seen the whole input file */
+  if ((*cinfo->methods->read_scan_header) (cinfo))
+    ERREXIT(cinfo->emethods, "Didn't expect more than one scan");
+
+  /* Now that we've collected the data, let the color quantizer do its thing */
+  (*cinfo->methods->color_quant_doit) (cinfo, scan_big_image);
+
+  /* Release working memory */
+  free_MCU_row(cinfo, coeff_data);
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  if (cinfo->do_block_smoothing) {
+    free_MCU_row(cinfo, bsmooth[0]);
+    free_MCU_row(cinfo, bsmooth[1]);
+    free_MCU_row(cinfo, bsmooth[2]);
+  }
+#endif
+  free_sampling_buffer(cinfo, subsampled_data);
+  free_sampimage(cinfo, fullsize_data, (int) cinfo->num_components,
+		 (long) rows_in_mem);
+  (*cinfo->emethods->free_small_sarray)
+		(quantize_out, (long) rows_in_mem);
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    (*cinfo->emethods->free_big_sarray) (fullsize_cnvt_image[ci]);
+  }
+  (*cinfo->emethods->free_small) ((void *) fullsize_cnvt_image);
+  (*cinfo->emethods->free_small) ((void *) fullsize_cnvt_ptrs);
+
+  /* Close up shop */
+  (*cinfo->methods->color_quant_term) (cinfo);
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Decompression pipeline controller used for multiple-scan files
+ * without 2-pass color quantization.
+ *
+ * The current implementation places the "big" buffer at the stage of
+ * desubsampled data.  Buffering subsampled data instead would reduce the
+ * size of temp files (by about a factor of 2 in typical cases).  However,
+ * the unsubsampling logic is dependent on the assumption that unsubsampling
+ * occurs during a scan, so it's much easier to do the enlargement as the
+ * JPEG file is read.  This also simplifies life for the memory manager,
+ * which would otherwise have to deal with overlapping access_big_sarray()
+ * requests.
+ *
+ * At present it appears that most JPEG files will be single-scan, so
+ * it doesn't seem worthwhile to try to make this implementation smarter.
+ */
+
+#ifdef MULTISCAN_FILES_SUPPORTED
+
+METHODDEF void
+multi_dcontroller (decompress_info_ptr cinfo)
+{
+  long fullsize_width;		/* # of samples per row in full-size buffers */
+  long cur_mcu_row;		/* counts # of MCU rows processed */
+  long pixel_rows_output;	/* # of pixel rows actually emitted */
+  int mcu_rows_per_loop;	/* # of MCU rows processed per outer loop */
+  /* Work buffer for dequantized coefficients (IDCT input) */
+  JBLOCKIMAGE coeff_data;
+  /* Work buffer for cross-block smoothing input */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  JBLOCKIMAGE bsmooth[3];	/* this is optional */
+  int whichb;
+#endif
+  /* Work buffer for subsampled image data (see comments at head of file) */
+  JSAMPIMAGE subsampled_data[2];
+  /* Full-image buffer holding desubsampled, but not color-converted, data */
+  big_sarray_ptr *fullsize_image;
+  JSAMPIMAGE fullsize_ptrs;	/* workspace for access_big_sarray() results */
+  /* Work buffer for color conversion output (full size) */
+  JSAMPIMAGE color_data;
+  int whichss, ri;
+  short ci, i;
+
+  /* Initialize for 1-pass color quantization, if needed */
+  if (cinfo->quantize_colors)
+    (*cinfo->methods->color_quant_init) (cinfo);
+
+  /* Compute dimensions of full-size pixel buffers */
+  /* Note these are the same whether interleaved or not. */
+  rows_in_mem = cinfo->max_v_samp_factor * DCTSIZE;
+  fullsize_width = jround_up(cinfo->image_width,
+			     (long) (cinfo->max_h_samp_factor * DCTSIZE));
+
+  /* Allocate all working memory that doesn't depend on scan info */
+  /* color_data is the result of the colorspace conversion step */
+  color_data = alloc_sampimage(cinfo, (int) cinfo->color_out_comps,
+			       (long) rows_in_mem, fullsize_width);
+  /* if quantizing colors, also need a one-component output area for that. */
+  if (cinfo->quantize_colors)
+    quantize_out = (*cinfo->emethods->alloc_small_sarray)
+				(fullsize_width, (long) rows_in_mem);
+
+  /* Get a big image: fullsize_image is sample data after unsubsampling. */
+  fullsize_image = (big_sarray_ptr *) (*cinfo->emethods->alloc_small)
+			(cinfo->num_components * SIZEOF(big_sarray_ptr));
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    fullsize_image[ci] = (*cinfo->emethods->request_big_sarray)
+			(fullsize_width,
+			 jround_up(cinfo->image_height, (long) rows_in_mem),
+			 (long) rows_in_mem);
+  }
+  /* Also get an area for pointers to currently accessible chunks */
+  fullsize_ptrs = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
+				(cinfo->num_components * SIZEOF(JSAMPARRAY));
+
+  /* Tell the memory manager to instantiate big arrays */
+  (*cinfo->emethods->alloc_big_arrays)
+	 /* extra sarray space is for subsampled-data buffers: */
+	((long) (fullsize_width			/* max width in samples */
+	 * cinfo->max_v_samp_factor*(DCTSIZE+2)	/* max height */
+	 * cinfo->num_components),		/* max components per scan */
+	 /* extra barray space is for MCU-row buffers: */
+	 (long) ((fullsize_width / DCTSIZE)	/* max width in blocks */
+	 * cinfo->max_v_samp_factor		/* max height */
+	 * cinfo->num_components		/* max components per scan */
+	 * (cinfo->do_block_smoothing ? 4 : 1)),/* how many of these we need */
+	 /* no extra "medium"-object space */
+	 /* NB: quantizer must get any such objects at color_quant_init time */
+	 (long) 0);
+
+
+  /* Loop over scans in file */
+
+  do {
+    
+    /* Prepare for this scan */
+    if (cinfo->comps_in_scan == 1) {
+      noninterleaved_scan_setup(cinfo);
+      /* Need to read Vk MCU rows to obtain Vk block rows */
+      mcu_rows_per_loop = cinfo->cur_comp_info[0]->v_samp_factor;
+    } else {
+      interleaved_scan_setup(cinfo);
+      /* in an interleaved scan, one MCU row provides Vk block rows */
+      mcu_rows_per_loop = 1;
+    }
+    
+    /* Allocate scan-local working memory */
+    /* coeff_data holds a single MCU row of coefficient blocks */
+    coeff_data = alloc_MCU_row(cinfo);
+    /* if doing cross-block smoothing, need extra space for its input */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+    if (cinfo->do_block_smoothing) {
+      bsmooth[0] = alloc_MCU_row(cinfo);
+      bsmooth[1] = alloc_MCU_row(cinfo);
+      bsmooth[2] = alloc_MCU_row(cinfo);
+    }
+#endif
+    /* subsampled_data is sample data before unsubsampling */
+    alloc_sampling_buffer(cinfo, subsampled_data);
+
+    /* line up the big buffers */
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      fullsize_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
+	(fullsize_image[cinfo->cur_comp_info[ci]->component_index],
+	 (long) 0, TRUE);
+    }
+    
+    /* Initialize to read scan data */
+    
+    (*cinfo->methods->entropy_decoder_init) (cinfo);
+    (*cinfo->methods->unsubsample_init) (cinfo);
+    (*cinfo->methods->disassemble_init) (cinfo);
+    
+    /* Loop over scan's data: rows_in_mem pixel rows are processed per loop */
+    
+    pixel_rows_output = 0;
+    whichss = 1;		/* arrange to start with subsampled_data[0] */
+    
+    for (cur_mcu_row = 0; cur_mcu_row < cinfo->MCU_rows_in_scan;
+	 cur_mcu_row += mcu_rows_per_loop) {
+      whichss ^= 1;		/* switch to other subsample buffer */
+
+      /* Obtain v_samp_factor block rows of each component in the scan. */
+      /* This is a single MCU row if interleaved, multiple MCU rows if not. */
+      /* In the noninterleaved case there might be fewer than v_samp_factor */
+      /* block rows remaining; if so, pad with copies of the last pixel row */
+      /* so that unsubsampling doesn't have to treat it as a special case. */
+      
+      for (ri = 0; ri < mcu_rows_per_loop; ri++) {
+	if (cur_mcu_row + ri < cinfo->MCU_rows_in_scan) {
+	  /* OK to actually read an MCU row. */
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+	  if (cinfo->do_block_smoothing)
+	    get_smoothed_row(cinfo, coeff_data,
+			     bsmooth, &whichb, cur_mcu_row + ri);
+	  else
+#endif
+	    (*cinfo->methods->disassemble_MCU) (cinfo, coeff_data);
+	  
+	  reverse_DCT(cinfo, coeff_data, subsampled_data[whichss],
+		      ri * DCTSIZE);
+	} else {
+	  /* Need to pad out with copies of the last subsampled row. */
+	  /* This can only happen if there is just one component. */
+	  duplicate_row(subsampled_data[whichss][0],
+			cinfo->cur_comp_info[0]->subsampled_width,
+			ri * DCTSIZE - 1, DCTSIZE);
+	}
+      }
+      
+      /* Unsubsample the data */
+      /* First time through is a special case */
+      
+      if (cur_mcu_row) {
+	/* Expand last row group of previous set */
+	expand(cinfo, subsampled_data[whichss], fullsize_ptrs, fullsize_width,
+	       (short) DCTSIZE, (short) (DCTSIZE+1), (short) 0,
+	       (short) (DCTSIZE-1));
+	/* Realign the big buffers */
+	pixel_rows_output += rows_in_mem;
+	for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	  fullsize_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
+	    (fullsize_image[cinfo->cur_comp_info[ci]->component_index],
+	     pixel_rows_output, TRUE);
+	}
+	/* Expand first row group of this set */
+	expand(cinfo, subsampled_data[whichss], fullsize_ptrs, fullsize_width,
+	       (short) (DCTSIZE+1), (short) 0, (short) 1,
+	       (short) 0);
+      } else {
+	/* Expand first row group with dummy above-context */
+	expand(cinfo, subsampled_data[whichss], fullsize_ptrs, fullsize_width,
+	       (short) (-1), (short) 0, (short) 1,
+	       (short) 0);
+      }
+      /* Expand second through next-to-last row groups of this set */
+      for (i = 1; i <= DCTSIZE-2; i++) {
+	expand(cinfo, subsampled_data[whichss], fullsize_ptrs, fullsize_width,
+	       (short) (i-1), (short) i, (short) (i+1),
+	       (short) i);
+      }
+    } /* end of outer loop */
+    
+    /* Expand the last row group with dummy below-context */
+    /* Note whichss points to last buffer side used */
+    expand(cinfo, subsampled_data[whichss], fullsize_ptrs, fullsize_width,
+	   (short) (DCTSIZE-2), (short) (DCTSIZE-1), (short) (-1),
+	   (short) (DCTSIZE-1));
+    
+    /* Clean up after the scan */
+    (*cinfo->methods->disassemble_term) (cinfo);
+    (*cinfo->methods->unsubsample_term) (cinfo);
+    (*cinfo->methods->entropy_decoder_term) (cinfo);
+    (*cinfo->methods->read_scan_trailer) (cinfo);
+
+    /* Release scan-local working memory */
+    free_MCU_row(cinfo, coeff_data);
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+    if (cinfo->do_block_smoothing) {
+      free_MCU_row(cinfo, bsmooth[0]);
+      free_MCU_row(cinfo, bsmooth[1]);
+      free_MCU_row(cinfo, bsmooth[2]);
+    }
+#endif
+    free_sampling_buffer(cinfo, subsampled_data);
+    
+    /* Repeat if there is another scan */
+  } while ((*cinfo->methods->read_scan_header) (cinfo));
+
+  /* Now that we've collected all the data, color convert & output it. */
+
+  for (pixel_rows_output = 0; pixel_rows_output < cinfo->image_height;
+       pixel_rows_output += rows_in_mem) {
+
+    /* realign the big buffers */
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      fullsize_ptrs[ci] = (*cinfo->emethods->access_big_sarray)
+	(fullsize_image[ci], pixel_rows_output, FALSE);
+    }
+
+    emit_1pass (cinfo,
+		(int) MIN(rows_in_mem, cinfo->image_height-pixel_rows_output),
+		fullsize_ptrs, color_data);
+  }
+
+  /* Release working memory */
+  free_sampimage(cinfo, color_data, (int) cinfo->color_out_comps,
+		 (long) rows_in_mem);
+  if (cinfo->quantize_colors)
+    (*cinfo->emethods->free_small_sarray)
+		(quantize_out, (long) rows_in_mem);
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    (*cinfo->emethods->free_big_sarray) (fullsize_image[ci]);
+  }
+  (*cinfo->emethods->free_small) ((void *) fullsize_image);
+  (*cinfo->emethods->free_small) ((void *) fullsize_ptrs);
+
+  /* Close up shop */
+  if (cinfo->quantize_colors)
+    (*cinfo->methods->color_quant_term) (cinfo);
+}
+
+#endif /* MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * Decompression pipeline controller used for multiple-scan files
+ * with 2-pass color quantization.
+ */
+
+#ifdef MULTISCAN_FILES_SUPPORTED
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF void
+multi_2quant_dcontroller (decompress_info_ptr cinfo)
+{
+  ERREXIT(cinfo->emethods, "Not implemented yet");
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+#endif /* MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * The method selection routine for decompression pipeline controllers.
+ * Note that at this point we've already read the JPEG header and first SOS,
+ * so we can tell whether the input is one scan or not.
+ */
+
+GLOBAL void
+jseldpipeline (decompress_info_ptr cinfo)
+{
+  /* simplify subsequent tests on color quantization */
+  if (! cinfo->quantize_colors)
+    cinfo->two_pass_quantize = FALSE;
+  
+  if (cinfo->comps_in_scan == cinfo->num_components) {
+    /* It's a single-scan file */
+#ifdef QUANT_2PASS_SUPPORTED
+    if (cinfo->two_pass_quantize)
+      cinfo->methods->d_pipeline_controller = single_2quant_dcontroller;
+    else
+#endif
+      cinfo->methods->d_pipeline_controller = single_dcontroller;
+  } else {
+    /* It's a multiple-scan file */
+#ifdef MULTISCAN_FILES_SUPPORTED
+#ifdef QUANT_2PASS_SUPPORTED
+    if (cinfo->two_pass_quantize)
+      cinfo->methods->d_pipeline_controller = multi_2quant_dcontroller;
+    else
+#endif
+      cinfo->methods->d_pipeline_controller = multi_dcontroller;
+#else
+    ERREXIT(cinfo->emethods, "Multiple-scan support was not compiled");
+#endif
+  }
+}
diff --git a/jdsample.c b/jdsample.c
new file mode 100644
index 0000000..15dbf4f
--- /dev/null
+++ b/jdsample.c
@@ -0,0 +1,133 @@
+/*
+ * jdsample.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains un-subsampling routines.
+ * These routines are invoked via the unsubsample and
+ * unsubsample_init/term methods.
+ */
+
+#include "jinclude.h"
+
+
+/*
+ * Initialize for un-subsampling a scan.
+ */
+
+METHODDEF void
+unsubsample_init (decompress_info_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+/*
+ * Un-subsample pixel values of a single component.
+ * This version only handles integral sampling ratios.
+ */
+
+METHODDEF void
+unsubsample (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)
+{
+  jpeg_component_info * compptr = cinfo->cur_comp_info[which_component];
+  short h_expand, v_expand, h, v;
+  int inrow, outrow;
+  long incol;
+  JSAMPROW inptr, outptr;
+  JSAMPLE invalue;
+
+  /* TEMP FOR DEBUGGING PIPELINE CONTROLLER */
+  if (input_rows != compptr->v_samp_factor ||
+      output_rows != cinfo->max_v_samp_factor ||
+      (input_cols % compptr->h_samp_factor) != 0 ||
+      (output_cols % cinfo->max_h_samp_factor) != 0 ||
+      output_cols*compptr->h_samp_factor != input_cols*cinfo->max_h_samp_factor)
+    ERREXIT(cinfo->emethods, "Bogus unsubsample parameters");
+
+  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+
+  outrow = 0;
+  for (inrow = 0; inrow < input_rows; inrow++) {
+    for (v = 0; v < v_expand; v++) {
+      inptr = input_data[inrow];
+      outptr = output_data[outrow++];
+      for (incol = 0; incol < input_cols; incol++) {
+	invalue = GETJSAMPLE(*inptr++);
+	for (h = 0; h < h_expand; h++) {
+	  *outptr++ = invalue;
+	}
+      }
+    }
+  }
+}
+
+
+/*
+ * Un-subsample pixel values of a single component.
+ * This version handles the special case of a full-size component.
+ */
+
+METHODDEF void
+fullsize_unsubsample (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)
+{
+  if (input_cols != output_cols || input_rows != output_rows) /* DEBUG */
+    ERREXIT(cinfo->emethods, "Pipeline controller messed up");
+
+  jcopy_sample_rows(input_data, 0, output_data, 0, output_rows, output_cols);
+}
+
+
+
+/*
+ * Clean up after a scan.
+ */
+
+METHODDEF void
+unsubsample_term (decompress_info_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+
+/*
+ * The method selection routine for unsubsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL void
+jselunsubsample (decompress_info_ptr cinfo)
+{
+  short ci;
+  jpeg_component_info * compptr;
+
+  if (cinfo->CCIR601_sampling)
+    ERREXIT(cinfo->emethods, "CCIR601 subsampling not implemented yet");
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+	compptr->v_samp_factor == cinfo->max_v_samp_factor)
+      cinfo->methods->unsubsample[ci] = fullsize_unsubsample;
+    else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+	     (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0)
+      cinfo->methods->unsubsample[ci] = unsubsample;
+    else
+      ERREXIT(cinfo->emethods, "Fractional subsampling not implemented yet");
+  }
+
+  cinfo->methods->unsubsample_init = unsubsample_init;
+  cinfo->methods->unsubsample_term = unsubsample_term;
+}
diff --git a/jerror.c b/jerror.c
new file mode 100644
index 0000000..591b185
--- /dev/null
+++ b/jerror.c
@@ -0,0 +1,67 @@
+/*
+ * jerror.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains simple error-reporting and trace-message routines.
+ * These are suitable for Unix-like systems and others where writing to
+ * stderr is the right thing to do.  If the JPEG software is integrated
+ * into a larger application, you may well need to replace these.
+ *
+ * The error_exit() routine should not return to its caller.  Within a
+ * larger application, you might want to have it do a longjmp() to return
+ * control to the outer user interface routine.  This should work since
+ * the portable JPEG code doesn't use setjmp/longjmp.  However, this won't
+ * release allocated memory or close temp files --- some bookkeeping would
+ * need to be added to the memory manager module to make that work.
+ *
+ * These routines are used by both the compression and decompression code.
+ */
+
+#include "jinclude.h"
+#ifdef __STDC__
+#include <stdlib.h>		/* to declare exit() */
+#endif
+
+
+static external_methods_ptr methods; /* saved for access to message_parm */
+
+
+METHODDEF void
+trace_message (char *msgtext)
+{
+  fprintf(stderr, msgtext,
+	  methods->message_parm[0], methods->message_parm[1],
+	  methods->message_parm[2], methods->message_parm[3],
+	  methods->message_parm[4], methods->message_parm[5],
+	  methods->message_parm[6], methods->message_parm[7]);
+  fprintf(stderr, "\n");
+}
+
+
+METHODDEF void
+error_exit (char *msgtext)
+{
+  trace_message(msgtext);
+  exit(1);
+}
+
+
+/*
+ * The method selection routine for simple error handling.
+ * The system-dependent setup routine should call this routine
+ * to install the necessary method pointers in the supplied struct.
+ */
+
+GLOBAL void
+jselerror (external_methods_ptr emethods)
+{
+  methods = emethods;		/* save struct addr for msg parm access */
+
+  emethods->error_exit = error_exit;
+  emethods->trace_message = trace_message;
+
+  emethods->trace_level = 0;	/* default = no tracing */
+}
diff --git a/jfwddct.c b/jfwddct.c
new file mode 100644
index 0000000..58291ac
--- /dev/null
+++ b/jfwddct.c
@@ -0,0 +1,179 @@
+/*
+ * jfwddct.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the basic DCT (Discrete Cosine Transform)
+ * transformation subroutine.
+ *
+ * This implementation is based on Appendix A.2 of the book
+ * "Discrete Cosine Transform---Algorithms, Advantages, Applications"
+ * by K.R. Rao and P. Yip  (Academic Press, Inc, London, 1990).
+ * It uses scaled fixed-point arithmetic instead of floating point.
+ */
+
+#include "jinclude.h"
+
+
+/* The poop on this scaling stuff is as follows:
+ *
+ * Most of the numbers (after multiplication by the constants) are
+ * (logically) shifted left by LG2_DCT_SCALE. This is undone by UNFIXH
+ * before assignment to the output array. Note that we want an additional
+ * division by 2 on the output (required by the equations).
+ *
+ * If right shifts are unsigned, then there is a potential problem.
+ * However, shifting right by 16 and then assigning to a short
+ * (assuming short = 16 bits) will keep the sign right!!
+ *
+ * For other shifts,
+ *
+ *     ((x + (1 << 30)) >> shft) - (1 << (30 - shft))
+ *
+ * gives a nice right shift with sign (assuming no overflow). However, all the
+ * scaling is such that this isn't a problem. (Is this true?)
+ */
+
+
+#define ONE 1L			/* remove L if long > 32 bits */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define LG2_DCT_SCALE 15
+#define RIGHT_SHIFT(_x,_shft)   ((((_x) + (ONE << 30)) >> (_shft)) - (ONE << (30 - (_shft))))
+#else
+#define LG2_DCT_SCALE 16
+#define RIGHT_SHIFT(_x,_shft)   ((_x) >> (_shft))
+#endif
+
+#define DCT_SCALE (ONE << LG2_DCT_SCALE)
+
+#define LG2_OVERSCALE 2
+#define OVERSCALE (ONE << LG2_OVERSCALE)
+
+#define FIX(x)  ((INT32) ((x) * DCT_SCALE + 0.5))
+#define FIXO(x)  ((INT32) ((x) * DCT_SCALE / OVERSCALE + 0.5))
+#define UNFIX(x)   RIGHT_SHIFT((x) + (ONE << (LG2_DCT_SCALE-1)), LG2_DCT_SCALE)
+#define UNFIXH(x)  RIGHT_SHIFT((x) + (ONE << LG2_DCT_SCALE), LG2_DCT_SCALE+1)
+#define UNFIXO(x)  RIGHT_SHIFT((x) + (ONE << (LG2_DCT_SCALE-1-LG2_OVERSCALE)), LG2_DCT_SCALE-LG2_OVERSCALE)
+#define OVERSH(x)   ((x) << LG2_OVERSCALE)
+
+#define SIN_1_4 FIX(0.7071067811856476)
+#define COS_1_4 SIN_1_4
+
+#define SIN_1_8 FIX(0.3826834323650898)
+#define COS_1_8 FIX(0.9238795325112870)
+#define SIN_3_8 COS_1_8
+#define COS_3_8 SIN_1_8
+
+#define SIN_1_16 FIX(0.1950903220161282)
+#define COS_1_16 FIX(0.9807852804032300)
+#define SIN_7_16 COS_1_16
+#define COS_7_16 SIN_1_16
+
+#define SIN_3_16 FIX(0.5555702330196022)
+#define COS_3_16 FIX(0.8314696123025450)
+#define SIN_5_16 COS_3_16
+#define COS_5_16 SIN_3_16
+
+#define OSIN_1_4 FIXO(0.707106781185647)
+#define OCOS_1_4 OSIN_1_4
+
+#define OSIN_1_8 FIXO(0.3826834323650898)
+#define OCOS_1_8 FIXO(0.9238795325112870)
+#define OSIN_3_8 OCOS_1_8
+#define OCOS_3_8 OSIN_1_8
+
+#define OSIN_1_16 FIXO(0.1950903220161282)
+#define OCOS_1_16 FIXO(0.9807852804032300)
+#define OSIN_7_16 OCOS_1_16
+#define OCOS_7_16 OSIN_1_16
+
+#define OSIN_3_16 FIXO(0.5555702330196022)
+#define OCOS_3_16 FIXO(0.8314696123025450)
+#define OSIN_5_16 OCOS_3_16
+#define OCOS_5_16 OSIN_3_16
+
+
+INLINE
+LOCAL void
+fast_dct_8 (DCTELEM *in, int stride)
+{
+  /* tmp1x are new values of tmpx -- flashy register colourers
+   * should be able to do this lot very well
+   */
+  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17;
+  INT32 tmp25, tmp26;
+  INT32 in0, in1, in2, in3, in4, in5, in6, in7;
+  
+  in0 = in[       0];
+  in1 = in[stride  ];
+  in2 = in[stride*2];
+  in3 = in[stride*3];
+  in4 = in[stride*4];
+  in5 = in[stride*5];
+  in6 = in[stride*6];
+  in7 = in[stride*7];
+  
+  tmp0 = in7 + in0;
+  tmp1 = in6 + in1;
+  tmp2 = in5 + in2;
+  tmp3 = in4 + in3;
+  tmp4 = in3 - in4;
+  tmp5 = in2 - in5;
+  tmp6 = in1 - in6;
+  tmp7 = in0 - in7;
+  
+  tmp10 = tmp3 + tmp0 ;
+  tmp11 = tmp2 + tmp1 ;
+  tmp12 = tmp1 - tmp2 ;
+  tmp13 = tmp0 - tmp3 ;
+  
+  /* Now using tmp10, tmp11, tmp12, tmp13 */
+  
+  in[       0] = UNFIXH((tmp10 + tmp11) * SIN_1_4);
+  in[stride*4] = UNFIXH((tmp10 - tmp11) * COS_1_4);
+  
+  in[stride*2] = UNFIXH(tmp13*COS_1_8 + tmp12*SIN_1_8);
+  in[stride*6] = UNFIXH(tmp13*SIN_1_8 - tmp12*COS_1_8);
+  
+  tmp16 = UNFIXO((tmp6 + tmp5) * SIN_1_4);
+  tmp15 = UNFIXO((tmp6 - tmp5) * COS_1_4);
+  
+  /* Now using tmp10, tmp11, tmp13, tmp14, tmp15, tmp16 */
+  
+  tmp14 = OVERSH(tmp4) + tmp15;
+  tmp25 = OVERSH(tmp4) - tmp15;
+  tmp26 = OVERSH(tmp7) - tmp16;
+  tmp17 = OVERSH(tmp7) + tmp16;
+  
+  /* These are now overscaled by OVERSCALE */
+  
+  /* tmp10, tmp11, tmp12, tmp13, tmp14, tmp25, tmp26, tmp17 */
+  
+  in[stride  ] = UNFIXH(tmp17*OCOS_1_16 + tmp14*OSIN_1_16);
+  in[stride*7] = UNFIXH(tmp17*OCOS_7_16 - tmp14*OSIN_7_16);
+  in[stride*5] = UNFIXH(tmp26*OCOS_5_16 + tmp25*OSIN_5_16);
+  in[stride*3] = UNFIXH(tmp26*OCOS_3_16 - tmp25*OSIN_3_16);
+}
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ *
+ * Note that this code is specialized to the case DCTSIZE = 8.
+ */
+
+GLOBAL void
+j_fwd_dct (DCTBLOCK data)
+{
+  int i;
+  
+  for (i = 0; i < DCTSIZE; i++)
+    fast_dct_8(data+i*DCTSIZE, 1);
+
+  for (i = 0; i < DCTSIZE; i++)
+    fast_dct_8(data+i, DCTSIZE);
+}
diff --git a/jinclude.h b/jinclude.h
new file mode 100644
index 0000000..ec7a7e8
--- /dev/null
+++ b/jinclude.h
@@ -0,0 +1,73 @@
+/*
+ * jinclude.h
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This is the central file that's #include'd by all the JPEG .c files.
+ * Its purpose is to provide a single place to fix any problems with
+ * including the wrong system include files.
+ * You can edit these declarations if you use a system with nonstandard
+ * system include files.
+ */
+
+
+/*
+ * <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 jvirtmem.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>.
+ */
+
+#ifndef __STDC__		/* shouldn't need this if __STDC__ */
+#include <sys/types.h>
+#endif
+
+/*
+ * In ANSI C, and indeed any rational implementation, size_t is also the
+ * type returned by sizeof().  However, it seems there are some irrational
+ * implementations out there, in which sizeof() returns an int even though
+ * size_t is defined as long or unsigned long.  To ensure consistent results
+ * we always use this SIZEOF() macro in place of using sizeof() directly.
+ */
+
+#define SIZEOF(object)	((size_t) sizeof(object))
+
+/*
+ * 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().
+ * NOTE: we assume the size parameters to these functions are of type size_t.
+ * Insert casts in these macros if not!
+ */
+
+#ifdef __STDC__
+#include <string.h>
+#define MEMZERO(voidptr,size)	memset((voidptr), 0, (size))
+#else /* not STDC */
+#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 /* STDC */
+
+
+/* Now include the portable JPEG definition files. */
+
+#include "jconfig.h"
+
+#include "jpegdata.h"
diff --git a/jpegdata.h b/jpegdata.h
new file mode 100644
index 0000000..3e4d753
--- /dev/null
+++ b/jpegdata.h
@@ -0,0 +1,812 @@
+/*
+ * jpegdata.h
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file 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++.
+ */
+
+#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 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) */
+typedef JSAMPARRAY *JSAMPIMAGE;	/* a 3-D sample array: top index is color */
+
+
+#define DCTSIZE		8	/* The basic DCT block is 8x8 samples */
+#define DCTSIZE2	64	/* DCTSIZE squared; # of elements in a block */
+
+typedef JCOEF JBLOCK[DCTSIZE2];	/* one block of coefficients */
+typedef JBLOCK FAR *JBLOCKROW;	/* pointer to one row of coefficient blocks */
+typedef JBLOCKROW *JBLOCKARRAY;		/* a 2-D array of coefficient blocks */
+typedef JBLOCKARRAY *JBLOCKIMAGE;	/* a 3-D array of coefficient blocks */
+
+typedef JCOEF FAR *JCOEFPTR;	/* useful in a couple of places */
+
+
+/* The input and output data of the DCT transform subroutines are of
+ * the following type, which need not be the same as JCOEF.
+ * For example, on a machine with fast floating point, it might make sense
+ * to recode the DCT routines to use floating point; then DCTELEM would be
+ * 'float' or 'double'.
+ */
+
+typedef JCOEF DCTELEM;
+typedef DCTELEM DCTBLOCK[DCTSIZE2];
+
+
+/* Types for JPEG compression parameters and working tables. */
+
+
+typedef enum {			/* defines known color spaces */
+	CS_UNKNOWN,		/* error/unspecified */
+	CS_GRAYSCALE,		/* monochrome (only 1 component) */
+	CS_RGB,			/* red/green/blue */
+	CS_YCbCr,		/* Y/Cb/Cr (also known as YUV) */
+	CS_YIQ,			/* Y/I/Q */
+	CS_CMYK			/* C/M/Y/K */
+} COLOR_SPACE;
+
+
+typedef struct {		/* Basic info about one component */
+  /* 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) */
+  /* 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) */
+  /* 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 */
+	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 */
+	/* the MCU dimensions; these are the working dimensions of the array */
+	/* as it is passed through the DCT or IDCT step.  NOTE: these values */
+	/* differ depending on whether the component is interleaved or not!! */
+} jpeg_component_info;
+
+
+/* DCT coefficient quantization tables.
+ * For 8-bit precision, 'INT16' should be good enough for quantization values;
+ * for more precision, we go for the full 16 bits.  'INT16' provides a useful
+ * speedup on many machines (multiplication & division of JCOEFs by
+ * 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 QUANT_VAL QUANT_TBL[DCTSIZE2];	/* A quantization table */
+typedef QUANT_VAL * QUANT_TBL_PTR;	/* pointer to same */
+
+
+typedef struct {		/* A Huffman coding table */
+  /* These two fields directly represent the contents of a JPEG DHT marker */
+	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.
+   */
+	UINT16 ehufco[256];	/* code for each symbol */
+	char ehufsi[256];	/* length of code for each symbol */
+	UINT16 mincode[17];	/* smallest code of length k */
+	INT32 maxcode[17];	/* largest code of length k (-1 if none) */
+	short valptr[17];	/* huffval[] index of 1st symbol of length k */
+} HUFF_TBL;
+
+
+#define NUM_QUANT_TBLS      4	/* quantization tables are numbered 0..3 */
+#define NUM_HUFF_TBLS       4	/* Huffman tables are numbered 0..3 */
+#define NUM_ARITH_TBLS      16	/* arith-coding tables are numbered 0..15 */
+#define MAX_COMPS_IN_SCAN   4	/* JPEG limit on # of components in one scan */
+#define MAX_SAMP_FACTOR     4	/* JPEG limit on sampling factors */
+#define MAX_BLOCKS_IN_MCU   10	/* JPEG limit on # of blocks in an MCU */
+
+
+/* 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_default_compression.
+ * 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 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;
+
+
+/* Working data for decompression */
+
+struct decompress_info_struct {
+/*
+ * These fields shall be established by the user interface before
+ * calling jpeg_decompress.  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: */
+
+	COLOR_SPACE out_color_space; /* colorspace of output */
+
+	double output_gamma;	/* image gamma wanted in output */
+
+	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;	/* number of colors to use */
+
+	boolean do_block_smoothing; /* T = apply cross-block smoothing */
+	boolean do_pixel_smoothing; /* T = apply post-subsampling smoothing */
+
+/*
+ * 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.
+ */
+	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 */
+
+	COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */
+
+        /* 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 */
+
+	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 arith-coding tables */
+	UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+	UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+	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 in output image */
+	/* (1 when quantizing colors, else same as color_out_comps) */
+
+/*
+ * These fields are valid during any one scan
+ */
+	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	2	/* may always do at least 2 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.
+ */
+
+typedef struct big_sarray_control * big_sarray_ptr;
+typedef struct big_barray_control * big_barray_ptr;
+
+
+/* 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));
+
+
+/* These structs contain function pointers for the various JPEG methods. */
+
+/* Routines to be provided by the surrounding application, rather than the
+ * portable JPEG code proper.  These are the same for compression and
+ * decompression.
+ */
+
+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, (char *msgtext));
+	METHOD(void, trace_message, (char *msgtext));
+
+	/* 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 */
+
+	int message_parm[8];	/* store numeric parms for messages here */
+
+	/* 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));
+#ifdef NEED_FAR_POINTERS	/* routines for getting far-heap space */
+	METHOD(void FAR *, alloc_medium, (size_t sizeofobject));
+	METHOD(void, free_medium, (void FAR *ptr));
+#else
+#define alloc_medium alloc_small
+#define free_medium  free_small
+#endif
+	METHOD(JSAMPARRAY, alloc_small_sarray, (long samplesperrow,
+						long numrows));
+	METHOD(void, free_small_sarray, (JSAMPARRAY ptr,
+					 long numrows));
+	METHOD(JBLOCKARRAY, alloc_small_barray, (long blocksperrow,
+						 long numrows));
+	METHOD(void, free_small_barray, (JBLOCKARRAY ptr,
+					 long numrows));
+	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));
+};
+
+/* 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 TRACEMS(emeth,lvl,msg)    \
+  ( (emeth)->trace_level >= (lvl) ? \
+   ((*(emeth)->trace_message) (msg), 0) : 0)
+#define TRACEMS1(emeth,lvl,msg,p1)    \
+  ( (emeth)->trace_level >= (lvl) ? \
+   ((emeth)->message_parm[0] = (p1), \
+    (*(emeth)->trace_message) (msg), 0) : 0)
+#define TRACEMS2(emeth,lvl,msg,p1,p2)    \
+  ( (emeth)->trace_level >= (lvl) ? \
+   ((emeth)->message_parm[0] = (p1), \
+    (emeth)->message_parm[1] = (p2), \
+    (*(emeth)->trace_message) (msg), 0) : 0)
+#define TRACEMS3(emeth,lvl,msg,p1,p2,p3)    \
+  ( (emeth)->trace_level >= (lvl) ? \
+   ((emeth)->message_parm[0] = (p1), \
+    (emeth)->message_parm[1] = (p2), \
+    (emeth)->message_parm[2] = (p3), \
+    (*(emeth)->trace_message) (msg), 0) : 0)
+#define TRACEMS4(emeth,lvl,msg,p1,p2,p3,p4)    \
+  ( (emeth)->trace_level >= (lvl) ? \
+   ((emeth)->message_parm[0] = (p1), \
+    (emeth)->message_parm[1] = (p2), \
+    (emeth)->message_parm[2] = (p3), \
+    (emeth)->message_parm[3] = (p4), \
+    (*(emeth)->trace_message) (msg), 0) : 0)
+#define TRACEMS8(emeth,lvl,msg,p1,p2,p3,p4,p5,p6,p7,p8)    \
+  ( (emeth)->trace_level >= (lvl) ? \
+   ((emeth)->message_parm[0] = (p1), \
+    (emeth)->message_parm[1] = (p2), \
+    (emeth)->message_parm[2] = (p3), \
+    (emeth)->message_parm[3] = (p4), \
+    (emeth)->message_parm[4] = (p5), \
+    (emeth)->message_parm[5] = (p6), \
+    (emeth)->message_parm[6] = (p7), \
+    (emeth)->message_parm[7] = (p8), \
+    (*(emeth)->trace_message) (msg), 0) : 0)
+
+
+/* Methods used during JPEG compression. */
+
+struct compress_methods_struct {
+	/* Hook for user interface to get control after input_init */
+	METHOD(void, c_ui_method_selection, (compress_info_ptr cinfo));
+	/* 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));
+	/* Gamma and color space 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. */
+
+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));
+	/* JPEG file scanning */
+	/* Note: user interface supplies read_jpeg_data for JFIF/raw-JPEG
+	 * reading.  For file formats that require random access (eg, TIFF)
+	 * the JPEG file header module will override the UI read_jpeg_data.
+	 */
+	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 */
+	METHOD(void, disassemble_init, (decompress_info_ptr cinfo));
+	METHOD(void, disassemble_MCU, (decompress_info_ptr cinfo,
+				       JBLOCKIMAGE image_data));
+	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));
+	/* Gamma and color space conversion */
+	METHOD(void, colorout_init, (decompress_info_ptr cinfo));
+	METHOD(void, color_convert, (decompress_info_ptr cinfo,
+				     int num_rows,
+				     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));
+	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));
+};
+
+
+/* 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. */
+
+#ifdef PROTO
+#define PP(arglist)	arglist
+#else
+#define PP(arglist)	()
+#endif
+
+
+/* main entry for compression */
+EXTERN void jpeg_compress PP((compress_info_ptr cinfo));
+/* default parameter setup for compression */
+EXTERN void j_default_compression PP((compress_info_ptr cinfo, int quality));
+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));
+EXTERN void j_free_defaults PP((compress_info_ptr cinfo));
+
+/* main entry for decompression */
+EXTERN void jpeg_decompress PP((decompress_info_ptr cinfo));
+
+/* 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 */
+/* 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 */
+
+/* method selection routines for system-dependent modules */
+EXTERN void jselerror PP((external_methods_ptr emethods)); /* jerror.c */
+EXTERN void jselvirtmem PP((external_methods_ptr emethods)); /* jvirtmem.c */
+
+/* debugging hook in jvirtmem.c */
+#ifdef MEM_STATS
+EXTERN void j_mem_stats PP((void));
+#endif
+
+/* Miscellaneous useful macros */
+
+#define MAX(a,b)	((a) > (b) ? (a) : (b))
+#define MIN(a,b)	((a) < (b) ? (a) : (b))
+
+
+#define RST0	0xD0		/* RST0 marker code */
diff --git a/jquant1.c b/jquant1.c
new file mode 100644
index 0000000..49dfd97
--- /dev/null
+++ b/jquant1.c
@@ -0,0 +1,387 @@
+/*
+ * jquant1.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains 1-pass color quantization (color mapping) routines.
+ * These routines are invoked via the methods color_quantize
+ * and color_quant_init/term.
+ */
+
+#include "jinclude.h"
+
+#ifdef QUANT_1PASS_SUPPORTED
+
+
+/*
+ * This implementation is a fairly dumb, quick-and-dirty quantizer;
+ * it's here mostly so that we can start working on colormapped output formats.
+ *
+ * We quantize to a color map that is selected in advance of seeing the image;
+ * the map depends only on the requested number of colors (at least 8).
+ * The map consists of all combinations of Ncolors[j] color values for each
+ * component j; we choose Ncolors[] based on the requested # of colors.
+ * We always use 0 and MAXJSAMPLE in each color (hence the minimum 8 colors).
+ * Any additional color values are equally spaced between these limits.
+ *
+ * The result almost always needs dithering to look decent.
+ */
+
+#define MAX_COMPONENTS 4	/* max components I can handle */
+
+static int total_colors;	/* Number of distinct output colors */
+static int Ncolors[MAX_COMPONENTS]; /* # of values alloced to each component */
+/* total_colors is the product of the Ncolors[] values */
+
+static JSAMPARRAY colormap;	/* The actual color map */
+/* colormap[i][j] = value of i'th color component for output pixel value j */
+
+static JSAMPARRAY colorindex;	/* Precomputed mapping for speed */
+/* colorindex[i][j] = index of color closest to pixel value j in component i,
+ * premultiplied so that the correct mapped value for a pixel (r,g,b) is:
+ *   colorindex[0][r] + colorindex[1][g] + colorindex[2][b]
+ */
+
+
+/* Declarations for Floyd-Steinberg dithering.
+ * Errors are accumulated into the arrays evenrowerrs[] and oddrowerrs[],
+ * each of which have #colors * (#columns + 2) entries (so that first/last
+ * pixels need not be special cases).  These have resolutions of 1/16th of
+ * a pixel count.  The error at a given pixel is propagated to its unprocessed
+ * neighbors using the standard F-S fractions,
+ *		...	(here)	7/16
+ *		3/16	5/16	1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * Note: on a wide image, we might not have enough room in a PC's near data
+ * segment to hold the error arrays; so they are allocated with alloc_medium.
+ */
+
+#ifdef EIGHT_BIT_SAMPLES
+typedef short FSERROR;		/* 16 bits should be enough */
+#else
+typedef INT32 FSERROR;		/* may need more than 16 bits? */
+#endif
+
+typedef FSERROR FAR *FSERRPTR;	/* pointer to error array (in FAR storage!) */
+
+static FSERRPTR evenrowerrs, oddrowerrs; /* current-row and next-row errors */
+static boolean on_odd_row;	/* flag to remember which row we are on */
+
+
+/*
+ * Initialize for one-pass color quantization.
+ */
+
+METHODDEF void
+color_quant_init (decompress_info_ptr cinfo)
+{
+  int max_colors = cinfo->desired_number_of_colors;
+  int i,j,k, ntc, nci, blksize, blkdist, ptr, val;
+
+  if (cinfo->color_out_comps > MAX_COMPONENTS)
+    ERREXIT1(cinfo->emethods, "Cannot quantize more than %d color components",
+	     MAX_COMPONENTS);
+  if (max_colors > (MAXJSAMPLE+1))
+    ERREXIT1(cinfo->emethods, "Cannot request more than %d quantized colors",
+	    MAXJSAMPLE+1);
+
+  /* Initialize to 2 color values for each component */
+  total_colors = 1;
+  for (i = 0; i < cinfo->color_out_comps; i++) {
+    Ncolors[i] = 2;
+    total_colors *= 2;
+  }
+  if (total_colors > max_colors)
+    ERREXIT1(cinfo->emethods, "Cannot quantize to fewer than %d colors",
+	     total_colors);
+
+  /* Increase the number of color values until requested limit is reached. */
+  /* Note that for standard RGB color space, we will have at least as many */
+  /* red values as green, and at least as many green values as blue. */
+  i = 0;			/* component index to increase next */
+  /* test calculates ntc = new total_colors if Ncolors[i] is incremented */
+  while ((ntc = (total_colors / Ncolors[i]) * (Ncolors[i]+1)) <= max_colors) {
+    Ncolors[i]++;		/* OK, apply the increment */
+    total_colors = ntc;
+    i++;			/* advance to next component */
+    if (i >= cinfo->color_out_comps) i = 0;
+  }
+
+  /* Report selected color counts */
+  if (cinfo->color_out_comps == 3)
+    TRACEMS4(cinfo->emethods, 1, "Quantizing to %d = %d*%d*%d colors",
+	     total_colors, Ncolors[0], Ncolors[1], Ncolors[2]);
+  else
+    TRACEMS1(cinfo->emethods, 1, "Quantizing to %d colors", total_colors);
+
+  /* Allocate and fill in the colormap and color index. */
+  /* The colors are ordered in the map in standard row-major order, */
+  /* i.e. rightmost (highest-indexed) color changes most rapidly. */
+
+  colormap = (*cinfo->emethods->alloc_small_sarray)
+		((long) total_colors, (long) cinfo->color_out_comps);
+  colorindex = (*cinfo->emethods->alloc_small_sarray)
+		((long) (MAXJSAMPLE+1), (long) cinfo->color_out_comps);
+
+  /* blksize is number of adjacent repeated entries for a component */
+  /* blkdist is distance between groups of identical entries for a component */
+  blkdist = total_colors;
+
+  for (i = 0; i < cinfo->color_out_comps; i++) {
+    /* fill in colormap entries for i'th color component */
+    nci = Ncolors[i];		/* # of distinct values for this color */
+    blksize = blkdist / nci;
+    for (j = 0; j < nci; j++) {
+      val = (j * MAXJSAMPLE + (nci-1)/2) / (nci-1); /* j'th value of color */
+      for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {
+	/* fill in blksize entries beginning at ptr */
+	for (k = 0; k < blksize; k++)
+	  colormap[i][ptr+k] = val;
+      }
+    }
+    blkdist = blksize;		/* blksize of this color is blkdist of next */
+
+    /* fill in colorindex entries for i'th color component */
+    for (j = 0; j <= MAXJSAMPLE; j++) {
+      /* compute index of color closest to pixel value j */
+      val = (j * (nci-1) + CENTERJSAMPLE) / MAXJSAMPLE;
+      /* premultiply so that no multiplication needed in main processing */
+      val *= blksize;
+      colorindex[i][j] = val;
+    }
+  }
+
+  /* Pass the colormap to the output module.  Note that the output */
+  /* module is allowed to save this pointer and use the map during */
+  /* any put_pixel_rows call! */
+  (*cinfo->methods->put_color_map) (cinfo, total_colors, colormap);
+
+  /* Allocate Floyd-Steinberg workspace if necessary */
+  if (cinfo->use_dithering) {
+    size_t arraysize = (cinfo->image_width + 2L) * cinfo->color_out_comps
+		       * SIZEOF(FSERROR);
+
+    evenrowerrs = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
+    oddrowerrs  = (FSERRPTR) (*cinfo->emethods->alloc_medium) (arraysize);
+    /* we only need to zero the forward contribution for current row. */
+    jzero_far((void FAR *) evenrowerrs, arraysize);
+    on_odd_row = FALSE;
+  }
+
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+METHODDEF void
+color_quantize (decompress_info_ptr cinfo, int num_rows,
+		JSAMPIMAGE input_data, JSAMPARRAY output_data)
+/* General case, no dithering */
+{
+  register int pixcode, ci;
+  register long col;
+  register int row;
+  register long widthm1 = cinfo->image_width - 1;
+  register int nc = cinfo->color_out_comps;  
+
+  for (row = 0; row < num_rows; row++) {
+    for (col = widthm1; col >= 0; col--) {
+      pixcode = 0;
+      for (ci = 0; ci < nc; ci++) {
+	pixcode += GETJSAMPLE(colorindex[ci]
+			      [GETJSAMPLE(input_data[ci][row][col])]);
+      }
+      output_data[row][col] = pixcode;
+    }
+  }
+}
+
+
+METHODDEF void
+color_quantize3 (decompress_info_ptr cinfo, int num_rows,
+		 JSAMPIMAGE input_data, JSAMPARRAY output_data)
+/* Fast path for color_out_comps==3, no dithering */
+{
+  register int pixcode;
+  register JSAMPROW ptr0, ptr1, ptr2, ptrout;
+  register long col;
+  register int row;
+  register long width = cinfo->image_width;
+
+  for (row = 0; row < num_rows; row++) {
+    ptr0 = input_data[0][row];
+    ptr1 = input_data[1][row];
+    ptr2 = input_data[2][row];
+    ptrout = output_data[row];
+    for (col = width; col > 0; col--) {
+      pixcode  = GETJSAMPLE(colorindex[0][GETJSAMPLE(*ptr0++)]);
+      pixcode += GETJSAMPLE(colorindex[1][GETJSAMPLE(*ptr1++)]);
+      pixcode += GETJSAMPLE(colorindex[2][GETJSAMPLE(*ptr2++)]);
+      *ptrout++ = pixcode;
+    }
+  }
+}
+
+
+METHODDEF void
+color_quantize_dither (decompress_info_ptr cinfo, int num_rows,
+		       JSAMPIMAGE input_data, JSAMPARRAY output_data)
+/* General case, with Floyd-Steinberg dithering */
+{
+  register int pixcode, ci;
+  register FSERROR val;
+  register FSERRPTR thisrowerr, nextrowerr;
+  register long col;
+  register int row;
+  register long width = cinfo->image_width;
+  register int nc = cinfo->color_out_comps;  
+
+  for (row = 0; row < num_rows; row++) {
+    if (on_odd_row) {
+      /* work right to left in this row */
+      thisrowerr = oddrowerrs + width*nc;
+      nextrowerr = evenrowerrs + width*nc;
+      for (ci = 0; ci < nc; ci++) /* need only initialize this one entry */
+	nextrowerr[ci] = 0;
+      for (col = width - 1; col >= 0; col--) {
+	/* select the output pixel value */
+	pixcode = 0;
+	for (ci = 0; ci < nc; ci++) {
+	  /* compute pixel value + accumulated error */
+	  val = (((FSERROR) GETJSAMPLE(input_data[ci][row][col])) << 4)
+		+ thisrowerr[ci];
+	  if (val < 0) val = 0;	/* must watch for range overflow! */
+	  else {
+	    val += 8;		/* divide by 16 with proper rounding */
+	    val >>= 4;
+	    if (val > MAXJSAMPLE) val = MAXJSAMPLE;
+	  }
+	  thisrowerr[ci] = val;	/* save for error propagation */
+	  pixcode += GETJSAMPLE(colorindex[ci][val]);
+	}
+	output_data[row][col] = pixcode;
+	/* propagate error to adjacent pixels */
+	for (ci = 0; ci < nc; ci++) {
+	  val = thisrowerr[ci] - GETJSAMPLE(colormap[ci][pixcode]);
+	  thisrowerr[ci-nc] += val * 7;
+	  nextrowerr[ci+nc] += val * 3;
+	  nextrowerr[ci   ] += val * 5;
+	  nextrowerr[ci-nc]  = val; /* not +=, since not initialized yet */
+	}
+	thisrowerr -= nc;	/* advance error ptrs to next pixel entry */
+	nextrowerr -= nc;
+      }
+      on_odd_row = FALSE;
+    } else {
+      /* work left to right in this row */
+      thisrowerr = evenrowerrs + nc;
+      nextrowerr = oddrowerrs + nc;
+      for (ci = 0; ci < nc; ci++) /* need only initialize this one entry */
+	nextrowerr[ci] = 0;
+      for (col = 0; col < width; col++) {
+	/* select the output pixel value */
+	pixcode = 0;
+	for (ci = 0; ci < nc; ci++) {
+	  /* compute pixel value + accumulated error */
+	  val = (((FSERROR) GETJSAMPLE(input_data[ci][row][col])) << 4)
+		+ thisrowerr[ci];
+	  if (val < 0) val = 0;	/* must watch for range overflow! */
+	  else {
+	    val += 8;		/* divide by 16 with proper rounding */
+	    val >>= 4;
+	    if (val > MAXJSAMPLE) val = MAXJSAMPLE;
+	  }
+	  thisrowerr[ci] = val;	/* save for error propagation */
+	  pixcode += GETJSAMPLE(colorindex[ci][val]);
+	}
+	output_data[row][col] = pixcode;
+	/* propagate error to adjacent pixels */
+	for (ci = 0; ci < nc; ci++) {
+	  val = thisrowerr[ci] - GETJSAMPLE(colormap[ci][pixcode]);
+	  thisrowerr[ci+nc] += val * 7;
+	  nextrowerr[ci-nc] += val * 3;
+	  nextrowerr[ci   ] += val * 5;
+	  nextrowerr[ci+nc]  = val; /* not +=, since not initialized yet */
+	}
+	thisrowerr += nc;	/* advance error ptrs to next pixel entry */
+	nextrowerr += nc;
+      }
+      on_odd_row = TRUE;
+    }
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+color_quant_term (decompress_info_ptr cinfo)
+{
+  /* We can't free the colormap until now, since output module may use it! */
+  (*cinfo->emethods->free_small_sarray)
+		(colormap, (long) cinfo->color_out_comps);
+  (*cinfo->emethods->free_small_sarray)
+		(colorindex, (long) cinfo->color_out_comps);
+  if (cinfo->use_dithering) {
+    (*cinfo->emethods->free_medium) ((void FAR *) evenrowerrs);
+    (*cinfo->emethods->free_medium) ((void FAR *) oddrowerrs);
+  }
+}
+
+
+/*
+ * Prescan some rows of pixels.
+ * Not used in one-pass case.
+ */
+
+METHODDEF void
+color_quant_prescan (decompress_info_ptr cinfo, int num_rows,
+		     JSAMPIMAGE image_data)
+{
+  ERREXIT(cinfo->emethods, "Should not get here!");
+}
+
+
+/*
+ * Do two-pass quantization.
+ * Not used in one-pass case.
+ */
+
+METHODDEF void
+color_quant_doit (decompress_info_ptr cinfo, quantize_caller_ptr source_method)
+{
+  ERREXIT(cinfo->emethods, "Should not get here!");
+}
+
+
+/*
+ * The method selection routine for 1-pass color quantization.
+ */
+
+GLOBAL void
+jsel1quantize (decompress_info_ptr cinfo)
+{
+  if (! cinfo->two_pass_quantize) {
+    cinfo->methods->color_quant_init = color_quant_init;
+    if (cinfo->use_dithering) {
+      cinfo->methods->color_quantize = color_quantize_dither;
+    } else {
+      if (cinfo->color_out_comps == 3)
+	cinfo->methods->color_quantize = color_quantize3;
+      else
+	cinfo->methods->color_quantize = color_quantize;
+    }
+    cinfo->methods->color_quant_prescan = color_quant_prescan;
+    cinfo->methods->color_quant_doit = color_quant_doit;
+    cinfo->methods->color_quant_term = color_quant_term;
+  }
+}
+
+#endif /* QUANT_1PASS_SUPPORTED */
diff --git a/jquant2.c b/jquant2.c
new file mode 100644
index 0000000..2569b20
--- /dev/null
+++ b/jquant2.c
@@ -0,0 +1,122 @@
+/*
+ * jquant2.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains 2-pass color quantization (color mapping) routines.
+ * These routines are invoked via the methods color_quant_prescan,
+ * color_quant_doit, and color_quant_init/term.
+ */
+
+#include "jinclude.h"
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+
+/*
+ * Initialize for two-pass color quantization.
+ */
+
+METHODDEF void
+color_quant_init (decompress_info_ptr cinfo)
+{
+  TRACEMS(cinfo->emethods, 1, "color_quant_init 2 pass");
+}
+
+
+/*
+ * Prescan some rows of pixels.
+ * Note: this could change the data being written into the big image array,
+ * if there were any benefit to doing so.  The doit routine is not allowed
+ * to modify the big image array, because the memory manager is not required
+ * to support multiple write passes on a big image.
+ */
+
+METHODDEF void
+color_quant_prescan (decompress_info_ptr cinfo, int num_rows,
+		     JSAMPIMAGE image_data)
+{
+  TRACEMS1(cinfo->emethods, 2, "color_quant_prescan %d rows", num_rows);
+}
+
+
+/*
+ * This routine makes the final pass over the image data.
+ * output_workspace is a one-component array of pixel dimensions at least
+ * as large as the input image strip; it can be used to hold the converted
+ * pixels' colormap indexes.
+ */
+
+METHODDEF void
+final_pass (decompress_info_ptr cinfo, int num_rows,
+	    JSAMPIMAGE image_data, JSAMPARRAY output_workspace)
+{
+  TRACEMS1(cinfo->emethods, 2, "final_pass %d rows", num_rows);
+  /* for debug purposes, just emit input data */
+  /* NB: this only works for PPM output */
+  (*cinfo->methods->put_pixel_rows) (cinfo, num_rows, image_data);
+}
+
+
+/*
+ * Perform two-pass quantization: rescan the image data and output the
+ * converted data via put_color_map and put_pixel_rows.
+ * The source_method is a routine that can scan the image data; it can
+ * be called as many times as desired.  The processing routine called by
+ * source_method has the same interface as color_quantize does in the
+ * one-pass case, except it must call put_pixel_rows itself.  (This allows
+ * me to use multiple passes in which earlier passes don't output anything.)
+ */
+
+METHODDEF void
+color_quant_doit (decompress_info_ptr cinfo, quantize_caller_ptr source_method)
+{
+  TRACEMS(cinfo->emethods, 1, "color_quant_doit 2 pass");
+  (*source_method) (cinfo, final_pass);
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+color_quant_term (decompress_info_ptr cinfo)
+{
+  TRACEMS(cinfo->emethods, 1, "color_quant_term 2 pass");
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ * Not used in two-pass case.
+ */
+
+METHODDEF void
+color_quantize (decompress_info_ptr cinfo, int num_rows,
+		JSAMPIMAGE input_data, JSAMPARRAY output_data)
+{
+  ERREXIT(cinfo->emethods, "Should not get here!");
+}
+
+
+/*
+ * The method selection routine for 2-pass color quantization.
+ */
+
+GLOBAL void
+jsel2quantize (decompress_info_ptr cinfo)
+{
+  if (cinfo->two_pass_quantize) {
+    /* just one alternative for the moment */
+    cinfo->methods->color_quant_init = color_quant_init;
+    cinfo->methods->color_quant_prescan = color_quant_prescan;
+    cinfo->methods->color_quant_doit = color_quant_doit;
+    cinfo->methods->color_quant_term = color_quant_term;
+    cinfo->methods->color_quantize = color_quantize;
+  }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
diff --git a/jrdgif.c b/jrdgif.c
new file mode 100644
index 0000000..e2d4b33
--- /dev/null
+++ b/jrdgif.c
@@ -0,0 +1,620 @@
+/*
+ * jrdgif.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to read input images in GIF format.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume input from
+ * an ordinary stdio stream.  They further assume that reading begins
+ * at the start of the file; input_init may need work if the
+ * user interface has already read some data (e.g., to determine that
+ * the file is indeed GIF format).
+ *
+ * These routines are invoked via the methods get_input_row
+ * and input_init/term.
+ */
+
+/*
+ * This code is loosely based on giftoppm from the PBMPLUS distribution
+ * of Feb. 1991.  That file contains the following copyright notice:
+ * +-------------------------------------------------------------------+
+ * | Copyright 1990, David Koblas.                                     |
+ * |   Permission to use, copy, modify, and distribute this software   |
+ * |   and its documentation for any purpose and without fee is hereby |
+ * |   granted, provided that the above copyright notice appear in all |
+ * |   copies and that both that copyright notice and this permission  |
+ * |   notice appear in supporting documentation.  This software is    |
+ * |   provided "as is" without express or implied warranty.           |
+ * +-------------------------------------------------------------------+
+ *
+ * We are also required to state that
+ *    "The Graphics Interchange Format(c) is the Copyright property of
+ *    CompuServe Incorporated. GIF(sm) is a Service Mark property of
+ *    CompuServe Incorporated."
+ */
+
+#include "jinclude.h"
+
+#ifdef GIF_SUPPORTED
+
+
+#define	MAXCOLORMAPSIZE	256	/* max # of colors in a GIF colormap */
+#define NUMCOLORS	3	/* # of colors */
+#define CM_RED		0	/* color component numbers */
+#define CM_GREEN	1
+#define CM_BLUE		2
+
+static JSAMPARRAY colormap;	/* the colormap to use */
+/* colormap[i][j] = value of i'th color component for pixel value j */
+
+#define	MAX_LZW_BITS	12	/* maximum LZW code size */
+#define LZW_TABLE_SIZE	(1<<MAX_LZW_BITS) /* # of possible LZW symbols */
+
+/* Macros for extracting header data --- note we assume chars may be signed */
+
+#define LM_to_uint(a,b)		((((b)&0xFF) << 8) | ((a)&0xFF))
+
+#define BitSet(byte, bit)	((byte) & (bit))
+#define INTERLACE	0x40	/* mask for bit signifying interlaced image */
+#define COLORMAPFLAG	0x80	/* mask for bit signifying colormap presence */
+
+#define	ReadOK(file,buffer,len)	(fread(buffer, 1, len, file) == (len))
+
+/* Static vars for GetCode and LZWReadByte */
+
+static char code_buf[256+4];	/* current input data block */
+static int last_byte;		/* # of bytes in code_buf */
+static int last_bit;		/* # of bits in code_buf */
+static int cur_bit;		/* next bit index to read */
+static boolean out_of_blocks;	/* TRUE if hit terminator data block */
+
+static int input_code_size;	/* codesize given in GIF file */
+static int clear_code,end_code; /* values for Clear and End codes */
+
+static int code_size;		/* current actual code size */
+static int limit_code;		/* 2^code_size */
+static int max_code;		/* first unused code value */
+static boolean first_time;	/* flags first call to LZWReadByte */
+
+/* LZW decompression tables:
+ *   symbol_head[K] = prefix symbol of any LZW symbol K (0..LZW_TABLE_SIZE-1)
+ *   symbol_tail[K] = suffix byte   of any LZW symbol K (0..LZW_TABLE_SIZE-1)
+ * Note that entries 0..end_code of the above tables are not used,
+ * since those symbols represent raw bytes or special codes.
+ *
+ * The stack represents the not-yet-used expansion of the last LZW symbol.
+ * In the worst case, a symbol could expand to as many bytes as there are
+ * LZW symbols, so we allocate LZW_TABLE_SIZE bytes for the stack.
+ * (This is conservative since that number includes the raw-byte symbols.)
+ *
+ * The tables are allocated from FAR heap space since they would use up
+ * rather a lot of the near data space in a PC.
+ */
+
+static UINT16 FAR *symbol_head; /* => table of prefix symbols */
+static UINT8  FAR *symbol_tail; /* => table of suffix bytes */
+static UINT8  FAR *symbol_stack; /* stack for symbol expansions */
+static UINT8  FAR *sp;		/* stack pointer */
+
+/* Static state for interlaced image processing */
+
+static boolean is_interlaced;	/* TRUE if have interlaced image */
+static big_sarray_ptr interlaced_image;	/* full image in interlaced order */
+static long cur_row_number;	/* need to know actual row number */
+static long pass2_offset;	/* # of pixel rows in pass 1 */
+static long pass3_offset;	/* # of pixel rows in passes 1&2 */
+static long pass4_offset;	/* # of pixel rows in passes 1,2,3 */
+
+
+/* Forward declarations */
+METHODDEF void load_interlaced_image PP((compress_info_ptr cinfo, JSAMPARRAY pixel_row));
+METHODDEF void get_interlaced_row PP((compress_info_ptr cinfo, JSAMPARRAY pixel_row));
+
+
+
+LOCAL int
+ReadByte (compress_info_ptr cinfo)
+/* Read next byte from GIF file */
+{
+  register FILE * infile = cinfo->input_file;
+  int c;
+
+  if ((c = getc(infile)) == EOF)
+    ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
+  return c;
+}
+
+
+LOCAL int
+GetDataBlock (compress_info_ptr cinfo, char *buf)
+/* Read a GIF data block, which has a leading count byte */
+/* A zero-length block marks the end of a data block sequence */
+{
+  int count;
+
+  count = ReadByte(cinfo);
+  if (count > 0) {
+    if (! ReadOK(cinfo->input_file, buf, count))
+      ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
+  }
+  return count;
+}
+
+
+LOCAL void
+SkipDataBlocks (compress_info_ptr cinfo)
+/* Skip a series of data blocks, until a block terminator is found */
+{
+  char buf[256];
+
+  while (GetDataBlock(cinfo, buf) > 0)
+    /* skip */;
+}
+
+
+LOCAL void
+ReInitLZW (void)
+/* (Re)initialize LZW state; shared code for startup and Clear processing */
+{
+  code_size = input_code_size+1;
+  limit_code = clear_code << 1;	/* 2^code_size */
+  max_code = clear_code + 2;	/* first unused code value */
+  sp = symbol_stack;		/* init stack to empty */
+}
+
+
+LOCAL void
+InitLZWCode (void)
+/* Initialize for a series of LZWReadByte (and hence GetCode) calls */
+{
+  /* GetCode initialization */
+  last_byte = 2;		/* make safe to "recopy last two bytes" */
+  last_bit = 0;			/* nothing in the buffer */
+  cur_bit = 0;			/* force buffer load on first call */
+  out_of_blocks = FALSE;
+
+  /* LZWReadByte initialization */
+  clear_code = 1 << input_code_size; /* compute special code values */
+  end_code = clear_code + 1;	/* note that these do not change */
+  first_time = TRUE;
+  ReInitLZW();
+}
+
+
+LOCAL int
+GetCode (compress_info_ptr cinfo)
+/* Fetch the next code_size bits from the GIF data */
+/* We assume code_size is less than 16 */
+{
+  register INT32 accum;
+  int offs, ret, count;
+
+  if ( (cur_bit+code_size) > last_bit) {
+    /* Time to reload the buffer */
+    if (out_of_blocks) {
+      TRACEMS(cinfo->emethods, 1, "Ran out of GIF bits");
+      return end_code;		/* fake something useful */
+    }
+    /* preserve last two bytes of what we have -- assume code_size <= 16 */
+    code_buf[0] = code_buf[last_byte-2];
+    code_buf[1] = code_buf[last_byte-1];
+    /* Load more bytes; set flag if we reach the terminator block */
+    if ((count = GetDataBlock(cinfo, &code_buf[2])) == 0) {
+      out_of_blocks = TRUE;
+      TRACEMS(cinfo->emethods, 1, "Ran out of GIF bits");
+      return end_code;		/* fake something useful */
+    }
+    /* Reset counters */
+    cur_bit = (cur_bit - last_bit) + 16;
+    last_byte = 2 + count;
+    last_bit = last_byte * 8;
+  }
+
+  /* Form up next 24 bits in accum */
+  offs = cur_bit >> 3;		/* byte containing cur_bit */
+#ifdef CHAR_IS_UNSIGNED
+  accum = code_buf[offs+2];
+  accum <<= 8;
+  accum |= code_buf[offs+1];
+  accum <<= 8;
+  accum |= code_buf[offs];
+#else
+  accum = code_buf[offs+2] & 0xFF;
+  accum <<= 8;
+  accum |= code_buf[offs+1] & 0xFF;
+  accum <<= 8;
+  accum |= code_buf[offs] & 0xFF;
+#endif
+
+  /* Right-align cur_bit in accum, then mask off desired number of bits */
+  accum >>= (cur_bit & 7);
+  ret = ((int) accum) & ((1 << code_size) - 1);
+  
+  cur_bit += code_size;
+  return ret;
+}
+
+
+LOCAL int
+LZWReadByte (compress_info_ptr cinfo)
+/* Read an LZW-compressed byte */
+{
+  static int oldcode;		/* previous LZW symbol */
+  static int firstcode;		/* first byte of oldcode's expansion */
+  register int code;		/* current working code */
+  int incode;			/* saves actual input code */
+
+  /* First time, just eat the expected Clear code(s) and return next code, */
+  /* which is assumed to be a raw byte. */
+  if (first_time) {
+    first_time = FALSE;
+    do {
+      code = GetCode(cinfo);
+    } while (code == clear_code);
+    firstcode = oldcode = code;	/* make firstcode, oldcode valid! */
+    return code;
+  }
+
+  /* If any codes are stacked from a previously read symbol, return them */
+  if (sp > symbol_stack)
+    return *(--sp);
+
+  code = GetCode(cinfo);
+
+  if (code == clear_code) {
+    /* Reinit static state, swallow any extra Clear codes, and return */
+    ReInitLZW();
+    do {
+      code = GetCode(cinfo);
+    } while (code == clear_code);
+    firstcode = oldcode = code; /* gotta reinit these too */
+    return code;
+  }
+
+  if (code == end_code) {
+    /* Skip the rest of the image, unless GetCode already read terminator */
+    if (! out_of_blocks)
+      SkipDataBlocks(cinfo);
+    return -1;
+  }
+
+  /* Normal raw byte or LZW symbol */
+  incode = code;		/* save for a moment */
+  
+  if (code >= max_code) {	/* special case for not-yet-defined symbol */
+    *sp++ = firstcode;		/* it will be defined as oldcode/firstcode */
+    code = oldcode;
+  }
+
+  /* If it's a symbol, expand it into the stack */
+  while (code >= clear_code) {
+    *sp++ = symbol_tail[code];	/* tail of symbol: a simple byte value */
+    code = symbol_head[code];	/* head of symbol: another LZW symbol */
+  }
+  /* At this point code just represents a raw byte */
+  firstcode = code;		/* save for possible future use */
+
+  /* If there's room in table, */
+  if ((code = max_code) < LZW_TABLE_SIZE) {
+    /* Define a new symbol = prev sym + head of this sym's expansion */
+    symbol_head[code] = oldcode;
+    symbol_tail[code] = firstcode;
+    max_code++;
+    /* Is it time to increase code_size? */
+    if ((max_code >= limit_code) && (code_size < MAX_LZW_BITS)) {
+      code_size++;
+      limit_code <<= 1;		/* keep equal to 2^code_size */
+    }
+  }
+  
+  oldcode = incode;		/* save last input symbol for future use */
+  return firstcode;		/* return first byte of symbol's expansion */
+}
+
+
+LOCAL void
+ReadColorMap (compress_info_ptr cinfo, int cmaplen, JSAMPARRAY cmap)
+/* Read a GIF colormap */
+{
+  int i;
+
+  for (i = 0; i < cmaplen; i++) {
+    cmap[CM_RED][i]   = ReadByte(cinfo);
+    cmap[CM_GREEN][i] = ReadByte(cinfo);
+    cmap[CM_BLUE][i]  = ReadByte(cinfo);
+  }
+}
+
+
+LOCAL void
+DoExtension (compress_info_ptr cinfo)
+/* Process an extension block */
+/* Currently we ignore 'em all */
+{
+  int extlabel;
+
+  /* Read extension label byte */
+  extlabel = ReadByte(cinfo);
+  TRACEMS1(cinfo->emethods, 1, "Ignoring GIF extension block of type 0x%02x",
+	   extlabel);
+  /* Skip the data block(s) associated with the extension */
+  SkipDataBlocks(cinfo);
+}
+
+
+/*
+ * Read the file header; return image size and component count.
+ */
+
+METHODDEF void
+input_init (compress_info_ptr cinfo)
+{
+  char hdrbuf[10];		/* workspace for reading control blocks */
+  UINT16 width, height;		/* image dimensions */
+  int colormaplen, aspectRatio;
+  int c;
+
+  /* Allocate space to store the colormap */
+  colormap = (*cinfo->emethods->alloc_small_sarray)
+		((long) MAXCOLORMAPSIZE, (long) NUMCOLORS);
+
+  /* Read and verify GIF Header */
+  if (! ReadOK(cinfo->input_file, hdrbuf, 6))
+    ERREXIT(cinfo->emethods, "Not a GIF file");
+  if (strncmp(hdrbuf, "GIF", 3) != 0)
+    ERREXIT(cinfo->emethods, "Not a GIF file");
+  /* Check for expected version numbers.
+   * If unknown version, give warning and try to process anyway;
+   * this is per recommendation in GIF89a standard.
+   */
+  if ((strncmp(hdrbuf+3, "87a", 3) != 0) &&
+      (strncmp(hdrbuf+3, "89a", 3) != 0))
+    TRACEMS3(cinfo->emethods, 1,
+	     "Warning: unexpected GIF version number '%c%c%c'",
+	     hdrbuf[3], hdrbuf[4], hdrbuf[5]);
+
+  /* Read and decipher Logical Screen Descriptor */
+  if (! ReadOK(cinfo->input_file, hdrbuf, 7))
+    ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
+  width = LM_to_uint(hdrbuf[0],hdrbuf[1]);
+  height = LM_to_uint(hdrbuf[2],hdrbuf[3]);
+  colormaplen = 2 << (hdrbuf[4] & 0x07);
+  /* we ignore the color resolution, sort flag, and background color index */
+  aspectRatio = hdrbuf[6] & 0xFF;
+  if (aspectRatio != 0 && aspectRatio != 49)
+    TRACEMS(cinfo->emethods, 1, "Warning: nonsquare pixels in input");
+
+  /* Read global colormap if header indicates it is present */
+  if (BitSet(hdrbuf[4], COLORMAPFLAG))
+    ReadColorMap(cinfo, colormaplen, colormap);
+
+  /* Scan until we reach start of desired image.
+   * We don't currently support skipping images, but could add it easily.
+   */
+  for (;;) {
+    c = ReadByte(cinfo);
+
+    if (c == ';')		/* GIF terminator?? */
+      ERREXIT(cinfo->emethods, "Too few images in GIF file");
+
+    if (c == '!') {		/* Extension */
+      DoExtension(cinfo);
+      continue;
+    }
+    
+    if (c != ',') {		/* Not an image separator? */
+      TRACEMS1(cinfo->emethods, 1, "Bogus input char 0x%02x, ignoring", c);
+      continue;
+    }
+
+    /* Read and decipher Local Image Descriptor */
+    if (! ReadOK(cinfo->input_file, hdrbuf, 9))
+      ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
+    /* we ignore top/left position info, also sort flag */
+    width = LM_to_uint(hdrbuf[4],hdrbuf[5]);
+    height = LM_to_uint(hdrbuf[6],hdrbuf[7]);
+    is_interlaced = BitSet(hdrbuf[8], INTERLACE);
+    colormaplen = 2 << (hdrbuf[8] & 0x07);
+
+    /* Read local colormap if header indicates it is present */
+    /* Note: if we wanted to support skipping images, */
+    /* we'd need to skip rather than read colormap for ignored images */
+    if (BitSet(hdrbuf[8], COLORMAPFLAG))
+      ReadColorMap(cinfo, colormaplen, colormap);
+
+    input_code_size = ReadByte(cinfo); /* get minimum-code-size byte */
+    if (input_code_size < 2 || input_code_size >= MAX_LZW_BITS)
+      ERREXIT1(cinfo->emethods, "Bogus codesize %d", input_code_size);
+
+    /* Reached desired image, so break out of loop */
+    /* If we wanted to skip this image, */
+    /* we'd call SkipDataBlocks and then continue the loop */
+    break;
+  }
+
+  /* Prepare to read selected image: first initialize LZW decompressor */
+  symbol_head = (UINT16 FAR *) (*cinfo->emethods->alloc_medium)
+				(LZW_TABLE_SIZE * SIZEOF(UINT16));
+  symbol_tail = (UINT8 FAR *) (*cinfo->emethods->alloc_medium)
+				(LZW_TABLE_SIZE * SIZEOF(UINT8));
+  symbol_stack = (UINT8 FAR *) (*cinfo->emethods->alloc_medium)
+				(LZW_TABLE_SIZE * SIZEOF(UINT8));
+  InitLZWCode();
+
+  /*
+   * If image is interlaced, we read it into a full-size sample array,
+   * decompressing as we go; then get_input_row selects rows from the
+   * sample array in the proper order.
+   */
+  if (is_interlaced) {
+    /* We request the big array now, but can't access it until the pipeline
+     * controller causes all the big arrays to be allocated.  Hence, the
+     * actual work of reading the image is postponed until the first call
+     * of get_input_row.
+     */
+    interlaced_image = (*cinfo->emethods->request_big_sarray)
+		((long) width, (long) height, (long) 1);
+    cinfo->methods->get_input_row = load_interlaced_image;
+  }
+
+  /* Return info about the image. */
+  cinfo->input_components = NUMCOLORS;
+  cinfo->in_color_space = CS_RGB;
+  cinfo->image_width = width;
+  cinfo->image_height = height;
+  cinfo->data_precision = 8;
+}
+
+
+/*
+ * Read one row of pixels.
+ * This version is used for noninterlaced GIF images:
+ * we read directly from the GIF file.
+ */
+
+METHODDEF void
+get_input_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
+{
+  register JSAMPROW ptr0, ptr1, ptr2;
+  register long col;
+  register int c;
+  
+  ptr0 = pixel_row[0];
+  ptr1 = pixel_row[1];
+  ptr2 = pixel_row[2];
+  for (col = cinfo->image_width; col > 0; col--) {
+    if ((c = LZWReadByte(cinfo)) < 0)
+      ERREXIT(cinfo->emethods, "Premature end of GIF image");
+    *ptr0++ = colormap[CM_RED][c];
+    *ptr1++ = colormap[CM_GREEN][c];
+    *ptr2++ = colormap[CM_BLUE][c];
+  }
+}
+
+
+/*
+ * Read one row of pixels.
+ * This version is used for the first call on get_input_row when
+ * reading an interlaced GIF file: we read the whole image into memory.
+ */
+
+METHODDEF void
+load_interlaced_image (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
+{
+  JSAMPARRAY image_ptr;
+  register JSAMPROW sptr;
+  register long col;
+  register int c;
+  long row;
+
+  /* Read the interlaced image into the big array we've created. */
+  for (row = 0; row < cinfo->image_height; row++) {
+    image_ptr = (*cinfo->emethods->access_big_sarray)
+			(interlaced_image, row, TRUE);
+    sptr = image_ptr[0];
+    for (col = cinfo->image_width; col > 0; col--) {
+      if ((c = LZWReadByte(cinfo)) < 0)
+	ERREXIT(cinfo->emethods, "Premature end of GIF image");
+      *sptr++ = c;
+    }
+  }
+
+  /* Replace method pointer so subsequent calls don't come here. */
+  cinfo->methods->get_input_row = get_interlaced_row;
+  /* Initialize for get_interlaced_row, and perform first call on it. */
+  cur_row_number = 0;
+  pass2_offset = (cinfo->image_height + 7L) / 8L;
+  pass3_offset = pass2_offset + (cinfo->image_height + 3L) / 8L;
+  pass4_offset = pass3_offset + (cinfo->image_height + 1L) / 4L;
+
+  get_interlaced_row(cinfo, pixel_row);
+}
+
+
+/*
+ * Read one row of pixels.
+ * This version is used for interlaced GIF images:
+ * we read from the big in-memory image.
+ */
+
+METHODDEF void
+get_interlaced_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
+{
+  JSAMPARRAY image_ptr;
+  register JSAMPROW sptr, ptr0, ptr1, ptr2;
+  register long col;
+  register int c;
+  long irow;
+
+  /* Figure out which row of interlaced image is needed, and access it. */
+  switch ((int) (cur_row_number & 7L)) {
+  case 0:			/* first-pass row */
+    irow = cur_row_number >> 3;
+    break;
+  case 4:			/* second-pass row */
+    irow = (cur_row_number >> 3) + pass2_offset;
+    break;
+  case 2:			/* third-pass row */
+  case 6:
+    irow = (cur_row_number >> 2) + pass3_offset;
+    break;
+  default:			/* fourth-pass row */
+    irow = (cur_row_number >> 1) + pass4_offset;
+    break;
+  }
+  image_ptr = (*cinfo->emethods->access_big_sarray)
+			(interlaced_image, irow, FALSE);
+  /* Scan the row, expand colormap, and output */
+  sptr = image_ptr[0];
+  ptr0 = pixel_row[0];
+  ptr1 = pixel_row[1];
+  ptr2 = pixel_row[2];
+  for (col = cinfo->image_width; col > 0; col--) {
+    c = GETJSAMPLE(*sptr++);
+    *ptr0++ = colormap[CM_RED][c];
+    *ptr1++ = colormap[CM_GREEN][c];
+    *ptr2++ = colormap[CM_BLUE][c];
+  }
+  cur_row_number++;		/* for next time */
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+input_term (compress_info_ptr cinfo)
+{
+  if (is_interlaced) {
+    (*cinfo->emethods->free_big_sarray) (interlaced_image);
+  }
+  (*cinfo->emethods->free_small_sarray)
+		(colormap, (long) NUMCOLORS);
+  (*cinfo->emethods->free_medium) ((void FAR *) symbol_head);
+  (*cinfo->emethods->free_medium) ((void FAR *) symbol_tail);
+  (*cinfo->emethods->free_medium) ((void FAR *) symbol_stack);
+}
+
+
+/*
+ * The method selection routine for GIF format input.
+ * Note that this must be called by the user interface before calling
+ * jpeg_compress.  If multiple input formats are supported, the
+ * user interface is responsible for discovering the file format and
+ * calling the appropriate method selection routine.
+ */
+
+GLOBAL void
+jselrgif (compress_info_ptr cinfo)
+{
+  cinfo->methods->input_init = input_init;
+  cinfo->methods->get_input_row = get_input_row; /* assume uninterlaced */
+  cinfo->methods->input_term = input_term;
+}
+
+#endif /* GIF_SUPPORTED */
diff --git a/jrdjfif.c b/jrdjfif.c
new file mode 100644
index 0000000..5ff14ba
--- /dev/null
+++ b/jrdjfif.c
@@ -0,0 +1,733 @@
+/*
+ * jrdjfif.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to decode standard JPEG file headers/markers.
+ * This will handle baseline and JFIF-convention JPEG files.
+ *
+ * This module relies on the JGETC macro and the read_jpeg_data method (which
+ * is provided by the user interface) to read from the JPEG data stream.
+ * Therefore, this module is NOT dependent on any particular assumption about
+ * the data source.  This fact does not carry over to more complex JPEG file
+ * formats such as JPEG-in-TIFF; those format control modules may well need to
+ * assume stdio input.
+ *
+ * read_file_header assumes that reading begins at the JPEG SOI marker
+ * (although it will skip non-FF bytes looking for a JPEG marker).
+ * The user interface must position the data stream appropriately.
+ *
+ * These routines are invoked via the methods read_file_header,
+ * read_scan_header, read_jpeg_data, read_scan_trailer, and read_file_trailer.
+ */
+
+#include "jinclude.h"
+
+#ifdef JFIF_SUPPORTED
+
+
+typedef enum {			/* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+  
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+  
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+  
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+  
+  M_DHT   = 0xc4,
+  
+  M_DAC   = 0xcc,
+  
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+  
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+  
+  M_APP0  = 0xe0,
+  M_APP15 = 0xef,
+  
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+  
+  M_TEM   = 0x01,
+  
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/*
+ * 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->bytes_in_buffer = fread(cinfo->input_buffer + MIN_UNGET,
+				 1, JPEG_BUF_SIZE,
+				 cinfo->input_file);
+  
+  cinfo->next_input_byte = cinfo->input_buffer + MIN_UNGET;
+  
+  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.
+ */
+
+
+LOCAL INT32
+get_2bytes (decompress_info_ptr cinfo)
+/* Get a 2-byte unsigned integer (e.g., a marker parameter length field) */
+{
+  INT32 a;
+  
+  a = JGETC(cinfo);
+  return (a << 8) + JGETC(cinfo);
+}
+
+
+LOCAL void
+skip_variable (decompress_info_ptr cinfo, int code)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+  INT32 length;
+  
+  length = get_2bytes(cinfo);
+  
+  TRACEMS2(cinfo->emethods, 1,
+	   "Skipping marker 0x%02x, length %d", code, length);
+  
+  for (length -= 2; length > 0; length--)
+    (void) JGETC(cinfo);
+}
+
+
+LOCAL void
+get_dht (decompress_info_ptr cinfo)
+/* Process a DHT marker */
+{
+  INT32 length;
+  UINT8 bits[17];
+  UINT8 huffval[256];
+  int i, index, count;
+  HUFF_TBL **htblptr;
+  
+  length = get_2bytes(cinfo)-2;
+  
+  while (length > 0) {
+    index = JGETC(cinfo);
+
+    TRACEMS1(cinfo->emethods, 1, "Define Huffman Table 0x%02x", index);
+      
+    bits[0] = 0;
+    count = 0;
+    for (i = 1; i <= 16; i++) {
+      bits[i] = JGETC(cinfo);
+      count += bits[i];
+    }
+
+    TRACEMS8(cinfo->emethods, 2, "        %3d %3d %3d %3d %3d %3d %3d %3d",
+	     bits[1], bits[2], bits[3], bits[4],
+	     bits[5], bits[6], bits[7], bits[8]);
+    TRACEMS8(cinfo->emethods, 2, "        %3d %3d %3d %3d %3d %3d %3d %3d",
+	     bits[9], bits[10], bits[11], bits[12],
+	     bits[13], bits[14], bits[15], bits[16]);
+
+    if (count > 256)
+      ERREXIT(cinfo->emethods, "Bogus DHT counts");
+
+    for (i = 0; i < count; i++)
+      huffval[i] = JGETC(cinfo);
+
+    length -= 1 + 16 + count;
+
+    if (index & 0x10) {		/* AC table definition */
+      index -= 0x10;
+      htblptr = &cinfo->ac_huff_tbl_ptrs[index];
+    } else {			/* DC table definition */
+      htblptr = &cinfo->dc_huff_tbl_ptrs[index];
+    }
+
+    if (index < 0 || index >= NUM_HUFF_TBLS)
+      ERREXIT1(cinfo->emethods, "Bogus DHT index %d", index);
+
+    if (*htblptr == NULL)
+      *htblptr = (*cinfo->emethods->alloc_small) (SIZEOF(HUFF_TBL));
+  
+    memcpy((void *) (*htblptr)->bits, (void *) bits,
+	   SIZEOF((*htblptr)->bits));
+    memcpy((void *) (*htblptr)->huffval, (void *) huffval,
+	   SIZEOF((*htblptr)->huffval));
+    }
+}
+
+
+LOCAL void
+get_dac (decompress_info_ptr cinfo)
+/* Process a DAC marker */
+{
+  INT32 length;
+  int index, val;
+
+  length = get_2bytes(cinfo)-2;
+  
+  while (length > 0) {
+    index = JGETC(cinfo);
+    val = JGETC(cinfo);
+
+    TRACEMS2(cinfo->emethods, 1,
+	     "Define Arithmetic Table 0x%02x: 0x%02x", index, val);
+
+    if (index < 0 || index >= (2*NUM_ARITH_TBLS))
+      ERREXIT1(cinfo->emethods, "Bogus DAC index %d", index);
+
+    if (index >= NUM_ARITH_TBLS) { /* define AC table */
+      cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = val;
+    } else {			/* define DC table */
+      cinfo->arith_dc_L[index] = val & 0x0F;
+      cinfo->arith_dc_U[index] = val >> 4;
+      if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
+	ERREXIT1(cinfo->emethods, "Bogus DAC value 0x%x", val);
+    }
+
+    length -= 2;
+  }
+}
+
+
+LOCAL void
+get_dqt (decompress_info_ptr cinfo)
+/* Process a DQT marker */
+{
+  INT32 length;
+  int n, i, prec;
+  UINT16 tmp;
+  QUANT_TBL_PTR quant_ptr;
+  
+  length = get_2bytes(cinfo) - 2;
+  
+  while (length > 0) {
+    n = JGETC(cinfo);
+    prec = n >> 4;
+    n &= 0x0F;
+
+    TRACEMS2(cinfo->emethods, 1,
+	     "Define Quantization Table %d  precision %d", n, prec);
+
+    if (n >= NUM_QUANT_TBLS)
+      ERREXIT1(cinfo->emethods, "Bogus table number %d", n);
+      
+    if (cinfo->quant_tbl_ptrs[n] == NULL)
+      cinfo->quant_tbl_ptrs[n] = (*cinfo->emethods->alloc_small) (SIZEOF(QUANT_TBL));
+    quant_ptr = cinfo->quant_tbl_ptrs[n];
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      tmp = JGETC(cinfo);
+      if (prec)
+	tmp = (tmp<<8) + JGETC(cinfo);
+      quant_ptr[i] = tmp;
+    }
+
+    for (i = 0; i < DCTSIZE2; i += 8) {
+      TRACEMS8(cinfo->emethods, 2, "        %4d %4d %4d %4d %4d %4d %4d %4d",
+	       quant_ptr[i  ], quant_ptr[i+1], quant_ptr[i+2], quant_ptr[i+3],
+	       quant_ptr[i+4], quant_ptr[i+5], quant_ptr[i+6], quant_ptr[i+7]);
+    }
+
+    length -= DCTSIZE2+1;
+    if (prec) length -= DCTSIZE2;
+  }
+}
+
+
+LOCAL void
+get_dri (decompress_info_ptr cinfo)
+/* Process a DRI marker */
+{
+  if (get_2bytes(cinfo) != 4)
+    ERREXIT(cinfo->emethods, "Bogus length in DRI");
+
+  cinfo->restart_interval = get_2bytes(cinfo);
+
+  TRACEMS1(cinfo->emethods, 1,
+	   "Define Restart Interval %d", cinfo->restart_interval);
+}
+
+
+LOCAL void
+get_app0 (decompress_info_ptr cinfo)
+/* Process an APP0 marker */
+{
+#define JFIF_LEN 14
+  INT32 length;
+  UINT8 b[JFIF_LEN];
+  int buffp;
+
+  length = get_2bytes(cinfo) - 2;
+
+  /* See if a JFIF APP0 marker is present */
+
+  if (length >= JFIF_LEN) {
+    for (buffp = 0; buffp < JFIF_LEN; buffp++)
+      b[buffp] = JGETC(cinfo);
+    length -= JFIF_LEN;
+
+    if (b[0]=='J' && b[1]=='F' && b[2]=='I' && b[3]=='F' && b[4]==0) {
+      /* Found JFIF APP0 marker: check version */
+      /* Major version must be 1 */
+      if (b[5] != 1)
+	ERREXIT2(cinfo->emethods, "Unsupported JFIF revision number %d.%02d",
+		 b[5], b[6]);
+      /* Minor version should be 0 or 1, but try to process anyway if newer */
+      if (b[6] != 0 && b[6] != 1)
+	TRACEMS2(cinfo->emethods, 0, "Warning: unknown JFIF revision number %d.%02d",
+		 b[5], b[6]);
+      /* Save info */
+      cinfo->density_unit = b[7];
+      cinfo->X_density = (b[8] << 8) + b[9];
+      cinfo->Y_density = (b[10] << 8) + b[11];
+      /* Assume colorspace is YCbCr, unless UI has overridden me */
+      if (cinfo->jpeg_color_space == CS_UNKNOWN)
+	cinfo->jpeg_color_space = CS_YCbCr;
+      TRACEMS3(cinfo->emethods, 1, "JFIF APP0 marker, density %dx%d  %d",
+	       cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
+    } else {
+      TRACEMS(cinfo->emethods, 1, "Unknown APP0 marker (not JFIF)");
+    }
+  } else {
+    TRACEMS1(cinfo->emethods, 1,
+	     "Short APP0 marker, length %d", (int) length);
+  }
+
+  while (length-- > 0)		/* skip any remaining data */
+    (void) JGETC(cinfo);
+}
+
+
+LOCAL void
+get_sof (decompress_info_ptr cinfo, int code)
+/* Process a SOFn marker */
+{
+  INT32 length;
+  short ci;
+  int c;
+  jpeg_component_info * compptr;
+  
+  length = get_2bytes(cinfo);
+  
+  cinfo->data_precision = JGETC(cinfo);
+  cinfo->image_height   = get_2bytes(cinfo);
+  cinfo->image_width    = get_2bytes(cinfo);
+  cinfo->num_components = JGETC(cinfo);
+
+  TRACEMS4(cinfo->emethods, 1,
+	   "Start Of Frame 0x%02x: width=%d, height=%d, components=%d",
+	   code, cinfo->image_width, cinfo->image_height,
+	   cinfo->num_components);
+
+  /* We don't support files in which the image height is initially specified */
+  /* as 0 and is later redefined by DNL.  As long as we have to check that,  */
+  /* might as well have a general sanity check. */
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+      || cinfo->num_components <= 0)
+    ERREXIT(cinfo->emethods, "Empty JPEG image (DNL not supported)");
+
+#ifdef EIGHT_BIT_SAMPLES
+  if (cinfo->data_precision != 8)
+    ERREXIT(cinfo->emethods, "Unsupported JPEG data precision");
+#endif
+#ifdef TWELVE_BIT_SAMPLES
+  if (cinfo->data_precision != 12) /* this needs more thought?? */
+    ERREXIT(cinfo->emethods, "Unsupported JPEG data precision");
+#endif
+#ifdef SIXTEEN_BIT_SAMPLES
+  if (cinfo->data_precision != 16) /* this needs more thought?? */
+    ERREXIT(cinfo->emethods, "Unsupported JPEG data precision");
+#endif
+
+  if (length != (cinfo->num_components * 3 + 8))
+    ERREXIT(cinfo->emethods, "Bogus SOF length");
+
+  cinfo->comp_info = (*cinfo->emethods->alloc_small)
+			(cinfo->num_components * SIZEOF(jpeg_component_info));
+  
+  for (ci = 0; ci < cinfo->num_components; ci++) {
+    compptr = &cinfo->comp_info[ci];
+    compptr->component_index = ci;
+    compptr->component_id = JGETC(cinfo);
+    c = JGETC(cinfo);
+    compptr->h_samp_factor = (c >> 4) & 15;
+    compptr->v_samp_factor = (c     ) & 15;
+    compptr->quant_tbl_no  = JGETC(cinfo);
+      
+    TRACEMS4(cinfo->emethods, 1, "    Component %d: %dhx%dv q=%d",
+	     compptr->component_id, compptr->h_samp_factor,
+	     compptr->v_samp_factor, compptr->quant_tbl_no);
+  }
+}
+
+
+LOCAL void
+get_sos (decompress_info_ptr cinfo)
+/* Process a SOS marker */
+{
+  INT32 length;
+  int i, ci, n, c, cc;
+  jpeg_component_info * compptr;
+  
+  length = get_2bytes(cinfo);
+  
+  n = JGETC(cinfo);  /* Number of components */
+  cinfo->comps_in_scan = n;
+  length -= 3;
+  
+  if (length != (n * 2 + 3) || n < 1 || n > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo->emethods, "Bogus SOS length");
+
+  TRACEMS1(cinfo->emethods, 1, "Start Of Scan: %d components", n);
+  
+  for (i = 0; i < n; i++) {
+    cc = JGETC(cinfo);
+    c = JGETC(cinfo);
+    length -= 2;
+    
+    for (ci = 0; ci < cinfo->num_components; ci++)
+      if (cc == cinfo->comp_info[ci].component_id)
+	break;
+    
+    if (ci >= cinfo->num_components)
+      ERREXIT(cinfo->emethods, "Invalid component number in SOS");
+    
+    compptr = &cinfo->comp_info[ci];
+    cinfo->cur_comp_info[i] = compptr;
+    compptr->dc_tbl_no = (c >> 4) & 15;
+    compptr->ac_tbl_no = (c     ) & 15;
+    
+    TRACEMS3(cinfo->emethods, 1, "    c%d: [dc=%d ac=%d]", cc,
+	     compptr->dc_tbl_no, compptr->ac_tbl_no);
+  }
+  
+  while (length > 0) {
+    (void) JGETC(cinfo);
+    length--;
+  }
+}
+
+
+LOCAL void
+get_soi (decompress_info_ptr cinfo)
+/* Process an SOI marker */
+{
+  int i;
+  
+  TRACEMS(cinfo->emethods, 1, "Start of Image");
+
+  /* Reset all parameters that are defined to be reset by SOI */
+
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+  cinfo->restart_interval = 0;
+
+  cinfo->density_unit = 0;	/* set default JFIF APP0 values */
+  cinfo->X_density = 1;
+  cinfo->Y_density = 1;
+
+  cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling */
+}
+
+
+LOCAL int
+next_marker (decompress_info_ptr cinfo)
+/* Find the next JPEG marker */
+/* Note that the output might not be a valid marker code, */
+/* but it will never be 0 or FF */
+{
+  int c, nbytes;
+
+  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 */
+
+  if (nbytes != 2)
+    TRACEMS2(cinfo->emethods, 1, "Skipped %d bytes before marker 0x%02x",
+	     nbytes-2, c);
+
+  return c;
+}
+
+
+LOCAL JPEG_MARKER
+process_tables (decompress_info_ptr cinfo)
+/* Scan and process JPEG markers that can appear in any order */
+/* Return when an SOI, EOI, SOFn, or SOS is found */
+{
+  int c;
+
+  while (TRUE) {
+    c = next_marker(cinfo);
+      
+    switch (c) {
+    case M_SOF0:
+    case M_SOF1:
+    case M_SOF2:
+    case M_SOF3:
+    case M_SOF5:
+    case M_SOF6:
+    case M_SOF7:
+    case M_JPG:
+    case M_SOF9:
+    case M_SOF10:
+    case M_SOF11:
+    case M_SOF13:
+    case M_SOF14:
+    case M_SOF15:
+    case M_SOI:
+    case M_EOI:
+    case M_SOS:
+      return c;
+      
+    case M_DHT:
+      get_dht(cinfo);
+      break;
+      
+    case M_DAC:
+      get_dac(cinfo);
+      break;
+      
+    case M_DQT:
+      get_dqt(cinfo);
+      break;
+      
+    case M_DRI:
+      get_dri(cinfo);
+      break;
+      
+    case M_APP0:
+      get_app0(cinfo);
+      break;
+
+    case M_RST0:		/* these are all parameterless */
+    case M_RST1:
+    case M_RST2:
+    case M_RST3:
+    case M_RST4:
+    case M_RST5:
+    case M_RST6:
+    case M_RST7:
+    case M_TEM:
+      TRACEMS1(cinfo->emethods, 1, "Unexpected marker 0x%02x", c);
+      break;
+
+    default:	/* must be DNL, DHP, EXP, APPn, JPGn, COM, or RESn */
+      skip_variable(cinfo, c);
+      break;
+    }
+  }
+}
+
+
+
+/*
+ * Initialize and read the file header (everything through the SOF marker).
+ */
+
+METHODDEF void
+read_file_header (decompress_info_ptr cinfo)
+{
+  int c;
+
+  /* Expect an SOI marker first */
+  if (next_marker(cinfo) == M_SOI)
+    get_soi(cinfo);
+  else
+    ERREXIT(cinfo->emethods, "File does not start with JPEG SOI marker");
+
+  /* Process markers until SOF */
+  c = process_tables(cinfo);
+
+  switch (c) {
+  case M_SOF0:
+  case M_SOF1:
+    get_sof(cinfo, c);
+    cinfo->arith_code = FALSE;
+    break;
+      
+  case M_SOF9:
+    get_sof(cinfo, c);
+    cinfo->arith_code = TRUE;
+    break;
+
+  default:
+    ERREXIT1(cinfo->emethods, "Unsupported SOF marker type 0x%02x", c);
+    break;
+  }
+
+  /* Figure out what colorspace we have */
+  /* (too bad the JPEG committee didn't provide a real way to specify this) */
+
+  switch (cinfo->num_components) {
+  case 1:
+    cinfo->jpeg_color_space = CS_GRAYSCALE;
+    break;
+
+  case 3:
+    /* if we saw a JFIF marker, leave it set to YCbCr; */
+    /* also leave it alone if UI has provided a value */
+    if (cinfo->jpeg_color_space == CS_UNKNOWN) {
+      short cid0 = cinfo->comp_info[0].component_id;
+      short cid1 = cinfo->comp_info[1].component_id;
+      short cid2 = cinfo->comp_info[2].component_id;
+
+      if (cid0 == 1 && cid1 == 2 && cid2 == 3)
+	cinfo->jpeg_color_space = CS_YCbCr; /* assume it's JFIF w/out marker */
+      else if (cid0 == 1 && cid1 == 4 && cid2 == 5)
+	cinfo->jpeg_color_space = CS_YIQ; /* prototype's YIQ matrix */
+      else {
+	TRACEMS3(cinfo->emethods, 0,
+		 "Unrecognized component IDs %d %d %d, assuming YCbCr",
+		 cid0, cid1, cid2);
+	cinfo->jpeg_color_space = CS_YCbCr;
+      }
+    }
+    break;
+
+  case 4:
+    cinfo->jpeg_color_space = CS_CMYK;
+    break;
+
+  default:
+    cinfo->jpeg_color_space = CS_UNKNOWN;
+    break;
+  }
+}
+
+
+/*
+ * Read the start of a scan (everything through the SOS marker).
+ * Return TRUE if find SOS, FALSE if find EOI.
+ */
+
+METHODDEF boolean
+read_scan_header (decompress_info_ptr cinfo)
+{
+  int c;
+  
+  /* Process markers until SOS or EOI */
+  c = process_tables(cinfo);
+  
+  switch (c) {
+  case M_SOS:
+    get_sos(cinfo);
+    return TRUE;
+    
+  case M_EOI:
+    TRACEMS(cinfo->emethods, 1, "End Of Image");
+    return FALSE;
+
+  default:
+    ERREXIT1(cinfo->emethods, "Unexpected marker 0x%02x", c);
+    break;
+  }
+  return FALSE;			/* keeps lint happy */
+}
+
+
+/*
+ * Finish up after a compressed scan (series of read_jpeg_data calls);
+ * prepare for another read_scan_header call.
+ */
+
+METHODDEF void
+read_scan_trailer (decompress_info_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+read_file_trailer (decompress_info_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * The method selection routine for standard JPEG header reading.
+ * Note that this must be called by the user interface before calling
+ * jpeg_decompress.  When a non-JFIF file is to be decompressed (TIFF,
+ * perhaps), the user interface must discover the file type and call
+ * the appropriate method selection routine.
+ */
+
+GLOBAL void
+jselrjfif (decompress_info_ptr cinfo)
+{
+  cinfo->methods->read_file_header = read_file_header;
+  cinfo->methods->read_scan_header = read_scan_header;
+  /* For JFIF/raw-JPEG format, the user interface supplies read_jpeg_data. */
+#if 0
+  cinfo->methods->read_jpeg_data = read_jpeg_data;
+#endif
+  cinfo->methods->read_scan_trailer = read_scan_trailer;
+  cinfo->methods->read_file_trailer = read_file_trailer;
+}
+
+#endif /* JFIF_SUPPORTED */
diff --git a/jrdppm.c b/jrdppm.c
new file mode 100644
index 0000000..15e2393
--- /dev/null
+++ b/jrdppm.c
@@ -0,0 +1,124 @@
+/*
+ * jrdppm.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to read input images in PPM format.
+ * The PBMPLUS library is required (well, it will be in the real version).
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume input from
+ * an ordinary stdio stream.  They further assume that reading begins
+ * at the start of the file; input_init may need work if the
+ * user interface has already read some data (e.g., to determine that
+ * the file is indeed PPM format).
+ *
+ * These routines are invoked via the methods get_input_row
+ * and input_init/term.
+ */
+
+#include "jinclude.h"
+
+#ifdef PPM_SUPPORTED
+
+
+/*
+ * Read the file header; return image size and component count.
+ */
+
+METHODDEF void
+input_init (compress_info_ptr cinfo)
+{
+  int c, w, h, prec;
+
+  if (getc(cinfo->input_file) != 'P')
+    ERREXIT(cinfo->emethods, "Not a PPM file");
+
+  c = getc(cinfo->input_file);
+  switch (c) {
+  case '5':			/* it's a PGM file */
+    cinfo->input_components = 1;
+    cinfo->in_color_space = CS_GRAYSCALE;
+    break;
+
+  case '6':			/* it's a PPM file */
+    cinfo->input_components = 3;
+    cinfo->in_color_space = CS_RGB;
+    break;
+
+  default:
+    ERREXIT(cinfo->emethods, "Not a PPM file");
+    break;
+  }
+
+  if (fscanf(cinfo->input_file, " %d %d %d", &w, &h, &prec) != 3)
+    ERREXIT(cinfo->emethods, "Not a PPM file");
+
+  if (getc(cinfo->input_file) != '\n' || w <= 0 || h <= 0 || prec != 255)
+    ERREXIT(cinfo->emethods, "Not a PPM file");
+
+  cinfo->image_width = w;
+  cinfo->image_height = h;
+  cinfo->data_precision = 8;
+}
+
+
+/*
+ * Read one row of pixels.
+ */
+
+METHODDEF void
+get_input_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
+{
+  register FILE * infile = cinfo->input_file;
+  register JSAMPROW ptr0, ptr1, ptr2;
+  register long col;
+  
+  if (cinfo->input_components == 1) {
+    ptr0 = pixel_row[0];
+    for (col = cinfo->image_width; col > 0; col--) {
+      *ptr0++ = getc(infile);
+    }
+  } else {
+    ptr0 = pixel_row[0];
+    ptr1 = pixel_row[1];
+    ptr2 = pixel_row[2];
+    for (col = cinfo->image_width; col > 0; col--) {
+      *ptr0++ = getc(infile);
+      *ptr1++ = getc(infile);
+      *ptr2++ = getc(infile);
+    }
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+input_term (compress_info_ptr cinfo)
+{
+  /* no work required */
+}
+
+
+/*
+ * The method selection routine for PPM format input.
+ * Note that this must be called by the user interface before calling
+ * jpeg_compress.  If multiple input formats are supported, the
+ * user interface is responsible for discovering the file format and
+ * calling the appropriate method selection routine.
+ */
+
+GLOBAL void
+jselrppm (compress_info_ptr cinfo)
+{
+  cinfo->methods->input_init = input_init;
+  cinfo->methods->get_input_row = get_input_row;
+  cinfo->methods->input_term = input_term;
+}
+
+#endif /* PPM_SUPPORTED */
diff --git a/jrevdct.c b/jrevdct.c
new file mode 100644
index 0000000..bafbf55
--- /dev/null
+++ b/jrevdct.c
@@ -0,0 +1,171 @@
+/*
+ * jrevdct.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the basic inverse-DCT transformation subroutine.
+ *
+ * This implementation is based on Appendix A.2 of the book
+ * "Discrete Cosine Transform---Algorithms, Advantages, Applications"
+ * by K.R. Rao and P. Yip  (Academic Press, Inc, London, 1990).
+ * It uses scaled fixed-point arithmetic instead of floating point.
+ */
+
+#include "jinclude.h"
+
+
+/* The poop on this scaling stuff is as follows:
+ *
+ * Most of the numbers (after multiplication by the constants) are
+ * (logically) shifted left by LG2_DCT_SCALE. This is undone by UNFIXH
+ * before assignment to the output array. Note that we want an additional
+ * division by 2 on the output (required by the equations).
+ *
+ * If right shifts are unsigned, then there is a potential problem.
+ * However, shifting right by 16 and then assigning to a short
+ * (assuming short = 16 bits) will keep the sign right!!
+ *
+ * For other shifts,
+ *
+ *     ((x + (1 << 30)) >> shft) - (1 << (30 - shft))
+ *
+ * gives a nice right shift with sign (assuming no overflow). However, all the
+ * scaling is such that this isn't a problem. (Is this true?)
+ */
+
+
+#define ONE 1L			/* remove L if long > 32 bits */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define LG2_DCT_SCALE 15
+#define RIGHT_SHIFT(_x,_shft)   ((((_x) + (ONE << 30)) >> (_shft)) - (ONE << (30 - (_shft))))
+#else
+#define LG2_DCT_SCALE 16
+#define RIGHT_SHIFT(_x,_shft)   ((_x) >> (_shft))
+#endif
+
+#define DCT_SCALE (ONE << LG2_DCT_SCALE)
+
+#define LG2_OVERSCALE 2
+#define OVERSCALE (ONE << LG2_OVERSCALE)
+
+#define FIX(x)  ((INT32) ((x) * DCT_SCALE + 0.5))
+#define FIXO(x)  ((INT32) ((x) * DCT_SCALE / OVERSCALE + 0.5))
+#define UNFIX(x)   RIGHT_SHIFT((x) + (ONE << (LG2_DCT_SCALE-1)), LG2_DCT_SCALE)
+#define UNFIXH(x)  RIGHT_SHIFT((x) + (ONE << LG2_DCT_SCALE), LG2_DCT_SCALE+1)
+#define UNFIXO(x)  RIGHT_SHIFT((x) + (ONE << (LG2_DCT_SCALE-1-LG2_OVERSCALE)), LG2_DCT_SCALE-LG2_OVERSCALE)
+#define OVERSH(x)   ((x) << LG2_OVERSCALE)
+
+#define SIN_1_4 FIX(0.7071067811856476)
+#define COS_1_4 SIN_1_4
+
+#define SIN_1_8 FIX(0.3826834323650898)
+#define COS_1_8 FIX(0.9238795325112870)
+#define SIN_3_8 COS_1_8
+#define COS_3_8 SIN_1_8
+
+#define SIN_1_16 FIX(0.1950903220161282)
+#define COS_1_16 FIX(0.9807852804032300)
+#define SIN_7_16 COS_1_16
+#define COS_7_16 SIN_1_16
+
+#define SIN_3_16 FIX(0.5555702330196022)
+#define COS_3_16 FIX(0.8314696123025450)
+#define SIN_5_16 COS_3_16
+#define COS_5_16 SIN_3_16
+
+#define OSIN_1_4 FIXO(0.707106781185647)
+#define OCOS_1_4 OSIN_1_4
+
+#define OSIN_1_8 FIXO(0.3826834323650898)
+#define OCOS_1_8 FIXO(0.9238795325112870)
+#define OSIN_3_8 OCOS_1_8
+#define OCOS_3_8 OSIN_1_8
+
+#define OSIN_1_16 FIXO(0.1950903220161282)
+#define OCOS_1_16 FIXO(0.9807852804032300)
+#define OSIN_7_16 OCOS_1_16
+#define OCOS_7_16 OSIN_1_16
+
+#define OSIN_3_16 FIXO(0.5555702330196022)
+#define OCOS_3_16 FIXO(0.8314696123025450)
+#define OSIN_5_16 OCOS_3_16
+#define OCOS_5_16 OSIN_3_16
+
+
+INLINE
+LOCAL void
+fast_idct_8 (DCTELEM *in, int stride)
+{
+  /* tmp1x are new values of tmpx -- flashy register colourers
+   * should be able to do this lot very well
+   */
+  INT32 tmp10, tmp11, tmp12, tmp13;
+  INT32 tmp20, tmp21, tmp22, tmp23;
+  INT32 tmp30, tmp31;
+  INT32 tmp40, tmp41, tmp42, tmp43;
+  INT32 tmp50, tmp51, tmp52, tmp53;
+  INT32 in0, in1, in2, in3, in4, in5, in6, in7;
+  
+  in0 = in[       0];
+  in1 = in[stride  ];
+  in2 = in[stride*2];
+  in3 = in[stride*3];
+  in4 = in[stride*4];
+  in5 = in[stride*5];
+  in6 = in[stride*6];
+  in7 = in[stride*7];
+  
+  tmp10 = (in0 + in4) * COS_1_4;
+  tmp11 = (in0 - in4) * COS_1_4;
+  tmp12 = in2 * SIN_1_8 - in6 * COS_1_8;
+  tmp13 = in6 * SIN_1_8 + in2 * COS_1_8;
+  
+  tmp20 = tmp10 + tmp13;
+  tmp21 = tmp11 + tmp12;
+  tmp22 = tmp11 - tmp12;
+  tmp23 = tmp10 - tmp13;
+  
+  tmp30 = UNFIXO((in3 + in5) * COS_1_4);
+  tmp31 = UNFIXO((in3 - in5) * COS_1_4);
+  
+  tmp40 = OVERSH(in1) + tmp30;
+  tmp41 = OVERSH(in7) + tmp31;
+  tmp42 = OVERSH(in1) - tmp30;
+  tmp43 = OVERSH(in7) - tmp31;
+  
+  tmp50 = tmp40 * OCOS_1_16 + tmp41 * OSIN_1_16;
+  tmp51 = tmp40 * OSIN_1_16 - tmp41 * OCOS_1_16;
+  tmp52 = tmp42 * OCOS_5_16 + tmp43 * OSIN_5_16;
+  tmp53 = tmp42 * OSIN_5_16 - tmp43 * OCOS_5_16;
+  
+  in[       0] = UNFIXH(tmp20 + tmp50);
+  in[stride  ] = UNFIXH(tmp21 + tmp53);
+  in[stride*2] = UNFIXH(tmp22 + tmp52);
+  in[stride*3] = UNFIXH(tmp23 + tmp51);
+  in[stride*4] = UNFIXH(tmp23 - tmp51);
+  in[stride*5] = UNFIXH(tmp22 - tmp52);
+  in[stride*6] = UNFIXH(tmp21 - tmp53);
+  in[stride*7] = UNFIXH(tmp20 - tmp50);
+}
+
+
+/*
+ * Perform the inverse DCT on one block of coefficients.
+ *
+ * Note that this code is specialized to the case DCTSIZE = 8.
+ */
+
+GLOBAL void
+j_rev_dct (DCTBLOCK data)
+{
+  int i;
+  
+  for (i = 0; i < DCTSIZE; i++)
+    fast_idct_8(data+i*DCTSIZE, 1);
+  
+  for (i = 0; i < DCTSIZE; i++)
+    fast_idct_8(data+i, DCTSIZE);
+}
diff --git a/jutils.c b/jutils.c
new file mode 100644
index 0000000..aebcaa9
--- /dev/null
+++ b/jutils.c
@@ -0,0 +1,106 @@
+/*
+ * jutils.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains miscellaneous utility routines needed for both
+ * compression and decompression.
+ * Note we prefix all global names with "j" to minimize conflicts with
+ * a surrounding application.
+ */
+
+#include "jinclude.h"
+
+
+GLOBAL long
+jround_up (long a, long b)
+/* Compute a rounded up to next multiple of b; a >= 0, b > 0 */
+{
+  a += b-1;
+  return a - (a % b);
+}
+
+
+GLOBAL void
+jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
+		   JSAMPARRAY output_array, int dest_row,
+		   int num_rows, long num_cols)
+/* Copy some rows of samples from one place to another.
+ * num_rows rows are copied from input_array[source_row++]
+ * to output_array[dest_row++]; these areas should not overlap.
+ * The source and destination arrays must be at least as wide as num_cols.
+ */
+{
+  /* On normal machines we can use memcpy().  This won't work on 80x86 because
+   * the sample arrays are FAR and we're assuming a small-pointer memory model.
+   */
+  register JSAMPROW inptr, outptr;
+#ifdef NEED_FAR_POINTERS
+  register long count;
+#else
+  register size_t count = num_cols * SIZEOF(JSAMPLE);
+#endif
+  register int row;
+
+  input_array += source_row;
+  output_array += dest_row;
+
+  for (row = num_rows; row > 0; row--) {
+    inptr = *input_array++;
+    outptr = *output_array++;
+#ifdef NEED_FAR_POINTERS
+    for (count = num_cols; count > 0; count--)
+      *outptr++ = *inptr++;	/* needn't bother with GETJSAMPLE() here */
+#else
+    memcpy((void *) outptr, (void *) inptr, count);
+#endif
+  }
+}
+
+
+GLOBAL void
+jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row, long num_blocks)
+/* Copy a row of coefficient blocks from one place to another. */
+{
+  /* On normal machines we can use memcpy().  This won't work on 80x86 because
+   * the block arrays are FAR and we're assuming a small-pointer memory model.
+   */
+#ifdef NEED_FAR_POINTERS
+  register JCOEFPTR inptr, outptr;
+  register int i;
+  register long count;
+
+  for (count = num_blocks; count > 0; count--) {
+    inptr = *input_row++;
+    outptr = *output_row++;
+    for (i = DCTSIZE2; i > 0; i--)
+      *outptr++ = *inptr++;
+  }
+#else
+    memcpy((void *) output_row, (void *) input_row,
+	   (size_t) (num_blocks * (DCTSIZE2 * SIZEOF(JCOEF))));
+#endif
+}
+
+
+GLOBAL void
+jzero_far (void FAR * target, size_t bytestozero)
+/* Zero out a chunk of FAR memory. */
+/* This might be sample-array data, block-array data, or alloc_medium data. */
+{
+  /* On normal machines we can use MEMZERO().  This won't work on 80x86
+   * because we're assuming a small-pointer memory model.
+   */
+#ifdef NEED_FAR_POINTERS
+  register char FAR * ptr = (char FAR *) target;
+  register size_t count;
+
+  for (count = bytestozero; count > 0; count--) {
+    *ptr++ = 0;
+  }
+#else
+  MEMZERO((void *) target, bytestozero);
+#endif
+}
diff --git a/jvirtmem.c b/jvirtmem.c
new file mode 100644
index 0000000..4a0627c
--- /dev/null
+++ b/jvirtmem.c
@@ -0,0 +1,548 @@
+/*
+ * jvirtmem.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides the system-dependent memory allocation routines
+ * for the case where we can rely on virtual memory to handle large arrays.
+ *
+ * This includes some MS-DOS code just for trial purposes; "big" arrays will
+ * have to be handled with temp files on MS-DOS, so a real implementation of
+ * a DOS memory manager will probably be a separate file.  (See additional
+ * comments about big arrays, below.)
+ * 
+ * NB: allocation routines never return NULL.
+ * They should exit to error_exit if unsuccessful.
+ */
+
+#include "jinclude.h"
+
+#ifdef __STDC__
+#include <stdlib.h>		/* to declare malloc(), free() */
+#else
+extern void * malloc PP((size_t size));
+extern void free PP((void *ptr));
+#endif
+
+
+/* Insert system-specific definitions of far_malloc, far_free here. */
+
+#ifndef NEED_FAR_POINTERS	/* Generic for non-braindamaged CPUs */
+
+#define far_malloc(x)	malloc(x)
+#define far_free(x)	free(x)
+
+#else /* NEED_FAR_POINTERS */
+
+#ifdef __TURBOC__
+/* These definitions work for Turbo C */
+#include <alloc.h>		/* need farmalloc(), farfree() */
+#define far_malloc(x)	farmalloc(x)
+#define far_free(x)	farfree(x)
+#else
+#ifdef MSDOS
+/* These definitions work for Microsoft C and compatible compilers */
+#include <malloc.h>		/* need _fmalloc(), _ffree() */
+#define far_malloc(x)	_fmalloc(x)
+#define far_free(x)	_ffree(x)
+#endif
+#endif
+
+#endif /* NEED_FAR_POINTERS */
+
+
+/*
+ * Some important notes:
+ *   The array alloc/dealloc routines are not merely a convenience;
+ *   on 80x86 machines the bottom-level pointers in an array are FAR
+ *   and thus may not be allocatable by alloc_small.
+ *
+ *   Also, it's not a good idea to try to merge the sarray and barray
+ *   routines, even though they are textually almost the same, because
+ *   samples are usually stored as bytes while coefficients are shorts.
+ *   Thus, in machines where byte pointers have a different representation
+ *   from word pointers, the resulting machine code could not be the same.
+ */
+
+
+static external_methods_ptr methods; /* saved for access to error_exit */
+
+
+#ifdef MEM_STATS		/* optional extra stuff for statistics */
+
+#define MALLOC_OVERHEAD  (SIZEOF(char *)) /* assumed overhead per request */
+#define MALLOC_FAR_OVERHEAD  (SIZEOF(char FAR *)) /* for "far" storage */
+
+static long total_num_small = 0;	/* total # of small objects alloced */
+static long total_bytes_small = 0;	/* total bytes requested */
+static long cur_num_small = 0;		/* # currently alloced */
+static long max_num_small = 0;		/* max simultaneously alloced */
+
+#ifdef NEED_FAR_POINTERS
+static long total_num_medium = 0;	/* total # of medium objects alloced */
+static long total_bytes_medium = 0;	/* total bytes requested */
+static long cur_num_medium = 0;		/* # currently alloced */
+static long max_num_medium = 0;		/* max simultaneously alloced */
+#endif
+
+static long total_num_sarray = 0;	/* total # of sarray objects alloced */
+static long total_bytes_sarray = 0;	/* total bytes requested */
+static long cur_num_sarray = 0;		/* # currently alloced */
+static long max_num_sarray = 0;		/* max simultaneously alloced */
+
+static long total_num_barray = 0;	/* total # of barray objects alloced */
+static long total_bytes_barray = 0;	/* total bytes requested */
+static long cur_num_barray = 0;		/* # currently alloced */
+static long max_num_barray = 0;		/* max simultaneously alloced */
+
+
+GLOBAL void
+j_mem_stats (void)
+{
+  /* since this is only a debugging stub, we can cheat a little on the
+   * trace message mechanism... helps 'cuz trace can't handle longs.
+   */
+  fprintf(stderr, "total_num_small = %ld\n", total_num_small);
+  fprintf(stderr, "total_bytes_small = %ld\n", total_bytes_small);
+  if (cur_num_small)
+    fprintf(stderr, "CUR_NUM_SMALL = %ld\n", cur_num_small);
+  fprintf(stderr, "max_num_small = %ld\n", max_num_small);
+  
+#ifdef NEED_FAR_POINTERS
+  fprintf(stderr, "total_num_medium = %ld\n", total_num_medium);
+  fprintf(stderr, "total_bytes_medium = %ld\n", total_bytes_medium);
+  if (cur_num_medium)
+    fprintf(stderr, "CUR_NUM_MEDIUM = %ld\n", cur_num_medium);
+  fprintf(stderr, "max_num_medium = %ld\n", max_num_medium);
+#endif
+  
+  fprintf(stderr, "total_num_sarray = %ld\n", total_num_sarray);
+  fprintf(stderr, "total_bytes_sarray = %ld\n", total_bytes_sarray);
+  if (cur_num_sarray)
+    fprintf(stderr, "CUR_NUM_SARRAY = %ld\n", cur_num_sarray);
+  fprintf(stderr, "max_num_sarray = %ld\n", max_num_sarray);
+  
+  fprintf(stderr, "total_num_barray = %ld\n", total_num_barray);
+  fprintf(stderr, "total_bytes_barray = %ld\n", total_bytes_barray);
+  if (cur_num_barray)
+    fprintf(stderr, "CUR_NUM_BARRAY = %ld\n", cur_num_barray);
+  fprintf(stderr, "max_num_barray = %ld\n", max_num_barray);
+}
+
+#endif /* MEM_STATS */
+
+
+LOCAL void
+out_of_memory (int which)
+/* Report an out-of-memory error and stop execution */
+/* If we compiled MEM_STATS support, report alloc requests before dying */
+{
+#ifdef MEM_STATS
+  j_mem_stats();
+#endif
+  ERREXIT1(methods, "Insufficient memory (case %d)", which);
+}
+
+
+
+METHODDEF void *
+alloc_small (size_t sizeofobject)
+/* Allocate a "small" (all-in-memory) object */
+{
+  void * result;
+
+#ifdef MEM_STATS
+  total_num_small++;
+  total_bytes_small += sizeofobject + MALLOC_OVERHEAD;
+  cur_num_small++;
+  if (cur_num_small > max_num_small) max_num_small = cur_num_small;
+#endif
+
+  result = malloc(sizeofobject);
+  if (result == NULL)
+    out_of_memory(1);
+  return result;
+}
+
+
+METHODDEF void
+free_small (void *ptr)
+/* Free a "small" (all-in-memory) object */
+{
+  free(ptr);
+
+#ifdef MEM_STATS
+  cur_num_small--;
+#endif
+}
+
+
+#ifdef NEED_FAR_POINTERS
+
+METHODDEF void FAR *
+alloc_medium (size_t sizeofobject)
+/* Allocate a "medium" (all in memory, but in far heap) object */
+{
+  void FAR * result;
+
+#ifdef MEM_STATS
+  total_num_medium++;
+  total_bytes_medium += sizeofobject + MALLOC_FAR_OVERHEAD;
+  cur_num_medium++;
+  if (cur_num_medium > max_num_medium) max_num_medium = cur_num_medium;
+#endif
+
+  result = far_malloc(sizeofobject);
+  if (result == NULL)
+    out_of_memory(2);
+  return result;
+}
+
+
+METHODDEF void
+free_medium (void FAR *ptr)
+/* Free a "medium" (all in memory, but in far heap) object */
+{
+  far_free(ptr);
+
+#ifdef MEM_STATS
+  cur_num_medium--;
+#endif
+}
+
+#endif /* NEED_FAR_POINTERS */
+
+
+METHODDEF JSAMPARRAY
+alloc_small_sarray (long samplesperrow, long numrows)
+/* Allocate a "small" (all-in-memory) 2-D sample array */
+{
+  JSAMPARRAY result;
+  long i;
+
+#ifdef MEM_STATS
+  total_num_sarray++;
+  total_bytes_sarray += (samplesperrow * SIZEOF(JSAMPLE) + MALLOC_FAR_OVERHEAD)
+			* numrows;
+  cur_num_sarray++;
+  if (cur_num_sarray > max_num_sarray) max_num_sarray = cur_num_sarray;
+#endif
+
+  /* Get space for row pointers; this is always "near" on 80x86 */
+  result = (JSAMPARRAY) alloc_small((size_t) (numrows * SIZEOF(JSAMPROW)));
+
+  /* Get the rows themselves; on 80x86 these are "far" */
+  for (i = 0; i < numrows; i++) {
+    result[i] = (JSAMPROW) far_malloc((size_t) (samplesperrow * SIZEOF(JSAMPLE)));
+    if (result[i] == NULL)
+      out_of_memory(3);
+  }
+
+  return result;
+}
+
+
+METHODDEF void
+free_small_sarray (JSAMPARRAY ptr, long numrows)
+/* Free a "small" (all-in-memory) 2-D sample array */
+{
+  long i;
+
+  /* Free the rows themselves; on 80x86 these are "far" */
+  for (i = 0; i < numrows; i++) {
+    far_free((void FAR *) ptr[i]);
+  }
+
+  /* Free space for row pointers; this is always "near" on 80x86 */
+  free_small((void *) ptr);
+
+#ifdef MEM_STATS
+  cur_num_sarray--;
+#endif
+}
+
+
+METHODDEF JBLOCKARRAY
+alloc_small_barray (long blocksperrow, long numrows)
+/* Allocate a "small" (all-in-memory) 2-D coefficient-block array */
+{
+  JBLOCKARRAY result;
+  long i;
+
+#ifdef MEM_STATS
+  total_num_barray++;
+  total_bytes_barray += (blocksperrow * SIZEOF(JBLOCK) + MALLOC_FAR_OVERHEAD)
+			* numrows;
+  cur_num_barray++;
+  if (cur_num_barray > max_num_barray) max_num_barray = cur_num_barray;
+#endif
+
+  /* Get space for row pointers; this is always "near" on 80x86 */
+  result = (JBLOCKARRAY) alloc_small((size_t) (numrows * SIZEOF(JBLOCKROW)));
+
+  /* Get the rows themselves; on 80x86 these are "far" */
+  for (i = 0; i < numrows; i++) {
+    result[i] = (JBLOCKROW) far_malloc((size_t) (blocksperrow * SIZEOF(JBLOCK)));
+    if (result[i] == NULL)
+      out_of_memory(4);
+  }
+
+  return result;
+}
+
+
+METHODDEF void
+free_small_barray (JBLOCKARRAY ptr, long numrows)
+/* Free a "small" (all-in-memory) 2-D coefficient-block array */
+{
+  long i;
+
+  /* Free the rows themselves; on 80x86 these are "far" */
+  for (i = 0; i < numrows; i++) {
+    far_free((void FAR *) ptr[i]);
+  }
+
+  /* Free space for row pointers; this is always "near" on 80x86 */
+  free_small((void *) ptr);
+
+#ifdef MEM_STATS
+  cur_num_barray--;
+#endif
+}
+
+
+
+/*
+ * About "big" array management:
+ *
+ * To allow machines with limited memory to handle large images,
+ * all processing in the JPEG system is done a few pixel or block rows
+ * at a time.  The above "small" array routines are only used to allocate
+ * strip buffers (as wide as the image, but just a few rows high).
+ * In some cases multiple passes must be made over the data.  In these
+ * cases the "big" array routines are used.  The array is still accessed
+ * a strip at a time, but the memory manager must save the whole array
+ * for repeated accesses.  The intended implementation is that there is
+ * a strip buffer in memory (as high as is possible given the desired memory
+ * limit), plus a backing file that holds the rest of the array.
+ *
+ * The request_big_array routines are told the total size of the image (in case
+ * it is useful to know the total file size that will be needed).  They are
+ * also given the unit height, which is the number of rows that will be
+ * accessed at once; the in-memory buffer should usually be made a multiple of
+ * this height for best efficiency.
+ *
+ * The request routines create control blocks (and may open backing files),
+ * but they don't create the in-memory buffers.  This is postponed until
+ * alloc_big_arrays is called.  At that time the total amount of space needed
+ * is known (approximately, anyway), so free memory can be divided up fairly.
+ *
+ * The access_big_array routines are responsible for making a specific strip
+ * area accessible (after reading or writing the backing file, if necessary).
+ * Note that the access routines are told whether the caller intends to modify
+ * the accessed strip; during a read-only pass this saves having to rewrite
+ * data to disk.
+ *
+ * The typical access pattern is one top-to-bottom pass to write the data,
+ * followed by one or more read-only top-to-bottom passes.  However, other
+ * access patterns may occur while reading.  For example, translation of image
+ * formats that use bottom-to-top scan order will require bottom-to-top read
+ * passes.  The memory manager need not support multiple write passes nor
+ * funny write orders (meaning that rearranging rows must be handled while
+ * reading data out of the big array, not while putting it in).
+ *
+ * In current usage, the access requests are always for nonoverlapping strips;
+ * that is, successive access start_row numbers always differ by exactly the
+ * unitheight.  This allows fairly simple buffer dump/reload logic if the
+ * in-memory buffer is made a multiple of the unitheight.  It would be
+ * possible to keep subsampled rather than fullsize data in the "big" arrays,
+ * thus reducing temp file size, if we supported overlapping strip access
+ * (access requests differing by less than the unitheight).  At the moment
+ * I don't believe this is worth the extra complexity.
+ *
+ * This particular implementation doesn't use temp files; the whole of a big
+ * array is allocated in (virtual) memory, and any swapping is done behind the
+ * scenes by the operating system.
+ */
+
+
+
+/* The control blocks for virtual arrays.
+ * These are pretty minimal in this implementation.
+ * Note: in this implementation we could realize big arrays
+ * at request time and make alloc_big_arrays a no-op;
+ * however, doing it separately keeps callers honest.
+ */
+
+struct big_sarray_control {
+	JSAMPARRAY mem_buffer;	/* memory buffer (the whole thing, here) */
+	long rows_in_mem;	/* Height of memory buffer */
+	long samplesperrow;	/* Width of memory buffer */
+	long unitheight;	/* # of rows accessed by access_big_sarray() */
+	big_sarray_ptr next;	/* list link for unrealized arrays */
+};
+
+struct big_barray_control {
+	JBLOCKARRAY mem_buffer;	/* memory buffer (the whole thing, here) */
+	long rows_in_mem;	/* Height of memory buffer */
+	long blocksperrow;	/* Width of memory buffer */
+	long unitheight;	/* # of rows accessed by access_big_barray() */
+	big_barray_ptr next;	/* list link for unrealized arrays */
+};
+
+
+/* Headers of lists of control blocks for unrealized big arrays */
+static big_sarray_ptr unalloced_sarrays;
+static big_barray_ptr unalloced_barrays;
+
+
+METHODDEF big_sarray_ptr
+request_big_sarray (long samplesperrow, long numrows, long unitheight)
+/* Request a "big" (virtual-memory) 2-D sample array */
+{
+  big_sarray_ptr result;
+
+  /* get control block */
+  result = (big_sarray_ptr) alloc_small(SIZEOF(struct big_sarray_control));
+
+  result->mem_buffer = NULL;	/* lets access routine spot premature access */
+  result->rows_in_mem = numrows;
+  result->samplesperrow = samplesperrow;
+  result->unitheight = unitheight;
+  result->next = unalloced_sarrays; /* add to list of unallocated arrays */
+  unalloced_sarrays = result;
+
+  return result;
+}
+
+
+METHODDEF big_barray_ptr
+request_big_barray (long blocksperrow, long numrows, long unitheight)
+/* Request a "big" (virtual-memory) 2-D coefficient-block array */
+{
+  big_barray_ptr result;
+
+  /* get control block */
+  result = (big_barray_ptr) alloc_small(SIZEOF(struct big_barray_control));
+
+  result->mem_buffer = NULL;	/* lets access routine spot premature access */
+  result->rows_in_mem = numrows;
+  result->blocksperrow = blocksperrow;
+  result->unitheight = unitheight;
+  result->next = unalloced_barrays; /* add to list of unallocated arrays */
+  unalloced_barrays = result;
+
+  return result;
+}
+
+
+METHODDEF void
+alloc_big_arrays (long extra_small_samples, long extra_small_blocks,
+		  long extra_medium_space)
+/* Allocate the in-memory buffers for any unrealized "big" arrays */
+/* 'extra' values are upper bounds for total future small-array requests */
+/* and far-heap requests */
+{
+  /* In this implementation we just malloc the whole arrays */
+  /* and expect the system's virtual memory to worry about swapping them */
+  big_sarray_ptr sptr;
+  big_barray_ptr bptr;
+
+  for (sptr = unalloced_sarrays; sptr != NULL; sptr = sptr->next) {
+    sptr->mem_buffer = alloc_small_sarray(sptr->samplesperrow,
+					  sptr->rows_in_mem);
+  }
+
+  for (bptr = unalloced_barrays; bptr != NULL; bptr = bptr->next) {
+    bptr->mem_buffer = alloc_small_barray(bptr->blocksperrow,
+					  bptr->rows_in_mem);
+  }
+
+  unalloced_sarrays = NULL;	/* reset for possible future cycles */
+  unalloced_barrays = NULL;
+}
+
+
+METHODDEF JSAMPARRAY
+access_big_sarray (big_sarray_ptr ptr, long start_row, boolean writable)
+/* Access the part of a "big" sample array starting at start_row */
+/* and extending for ptr->unitheight rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  /* debugging check */
+  if (start_row < 0 || start_row+ptr->unitheight > ptr->rows_in_mem ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(methods, "Bogus access_big_sarray request");
+
+  return ptr->mem_buffer + start_row;
+}
+
+
+METHODDEF JBLOCKARRAY
+access_big_barray (big_barray_ptr ptr, long start_row, boolean writable)
+/* Access the part of a "big" coefficient-block array starting at start_row */
+/* and extending for ptr->unitheight rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  /* debugging check */
+  if (start_row < 0 || start_row+ptr->unitheight > ptr->rows_in_mem ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(methods, "Bogus access_big_barray request");
+
+  return ptr->mem_buffer + start_row;
+}
+
+
+METHODDEF void
+free_big_sarray (big_sarray_ptr ptr)
+/* Free a "big" (virtual-memory) 2-D sample array */
+{
+  free_small_sarray(ptr->mem_buffer, ptr->rows_in_mem);
+  free_small((void *) ptr);	/* free the control block too */
+}
+
+
+METHODDEF void
+free_big_barray (big_barray_ptr ptr)
+/* Free a "big" (virtual-memory) 2-D coefficient-block array */
+{
+  free_small_barray(ptr->mem_buffer, ptr->rows_in_mem);
+  free_small((void *) ptr);	/* free the control block too */
+}
+
+
+
+/*
+ * The method selection routine for virtual memory systems.
+ * The system-dependent setup routine should call this routine
+ * to install the necessary method pointers in the supplied struct.
+ */
+
+GLOBAL void
+jselvirtmem (external_methods_ptr emethods)
+{
+  methods = emethods;		/* save struct addr for error exit access */
+
+  emethods->alloc_small = alloc_small;
+  emethods->free_small = free_small;
+#ifdef NEED_FAR_POINTERS
+  emethods->alloc_medium = alloc_medium;
+  emethods->free_medium = free_medium;
+#endif
+  emethods->alloc_small_sarray = alloc_small_sarray;
+  emethods->free_small_sarray = free_small_sarray;
+  emethods->alloc_small_barray = alloc_small_barray;
+  emethods->free_small_barray = free_small_barray;
+  emethods->request_big_sarray = request_big_sarray;
+  emethods->request_big_barray = request_big_barray;
+  emethods->alloc_big_arrays = alloc_big_arrays;
+  emethods->access_big_sarray = access_big_sarray;
+  emethods->access_big_barray = access_big_barray;
+  emethods->free_big_sarray = free_big_sarray;
+  emethods->free_big_barray = free_big_barray;
+
+  unalloced_sarrays = NULL;	/* make sure list headers are empty */
+  unalloced_barrays = NULL;
+}
diff --git a/jwrgif.c b/jwrgif.c
new file mode 100644
index 0000000..44062ec
--- /dev/null
+++ b/jwrgif.c
@@ -0,0 +1,497 @@
+/*
+ * jwrgif.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to write output images in GIF format.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume output to
+ * an ordinary stdio stream.
+ *
+ * These routines are invoked via the methods put_pixel_rows, put_color_map,
+ * and output_init/term.
+ */
+
+/*
+ * This code is loosely based on ppmtogif from the PBMPLUS distribution
+ * of Feb. 1991.  That file contains the following copyright notice:
+ *    Based on GIFENCODE by David Rowley <mgardi@watdscu.waterloo.edu>.
+ *    Lempel-Ziv compression based on "compress" by Spencer W. Thomas et al.
+ *    Copyright (C) 1989 by Jef Poskanzer.
+ *    Permission to use, copy, modify, and distribute this software and its
+ *    documentation for any purpose and without fee is hereby granted, provided
+ *    that the above copyright notice appear in all copies and that both that
+ *    copyright notice and this permission notice appear in supporting
+ *    documentation.  This software is provided "as is" without express or
+ *    implied warranty.
+ *
+ * We are also required to state that
+ *    "The Graphics Interchange Format(c) is the Copyright property of
+ *    CompuServe Incorporated. GIF(sm) is a Service Mark property of
+ *    CompuServe Incorporated."
+ */
+
+#include "jinclude.h"
+
+#ifdef GIF_SUPPORTED
+
+
+static decompress_info_ptr dcinfo; /* to avoid passing to all functions */
+
+#define	MAX_LZW_BITS	12	/* maximum LZW code size (4096 symbols) */
+
+typedef INT16 code_int;		/* must hold -1 .. 2**MAX_LZW_BITS */
+
+#define LZW_TABLE_SIZE	((code_int) 1 << MAX_LZW_BITS)
+
+#define HSIZE		5003	/* hash table size for 80% occupancy */
+
+typedef int hash_int;		/* must hold -2*HSIZE..2*HSIZE */
+
+static int n_bits;		/* current number of bits/code */
+static code_int maxcode;	/* maximum code, given n_bits */
+#define MAXCODE(n_bits)	(((code_int) 1 << (n_bits)) - 1)
+
+static int init_bits;		/* initial n_bits ... restored after clear */
+
+static code_int ClearCode;	/* clear code (doesn't change) */
+static code_int EOFCode;	/* EOF code (ditto) */
+
+static code_int free_code;	/* first not-yet-used symbol code */
+
+/*
+ * The LZW hash table consists of three parallel arrays:
+ *   hash_code[i]	code of symbol in slot i, or 0 if empty slot
+ *   hash_prefix[i]	symbol's prefix code; undefined if empty slot
+ *   hash_suffix[i]	symbol's suffix character; undefined if empty slot
+ * where slot values (i) range from 0 to HSIZE-1.
+ *
+ * Algorithm:  use open addressing double hashing (no chaining) on the
+ * prefix code / suffix character combination.  We do a variant of Knuth's
+ * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+ * secondary probe.
+ *
+ * The hash tables are allocated from FAR heap space since they would use up
+ * rather a lot of the near data space in a PC.
+ */
+
+static code_int FAR *hash_code;	/* => hash table of symbol codes */
+static code_int FAR *hash_prefix; /* => hash table of prefix symbols */
+static UINT8 FAR *hash_suffix;	/* => hash table of suffix bytes */
+
+
+/*
+ * Routines to package compressed data bytes into GIF data blocks.
+ * A data block consists of a count byte (1..255) and that many data bytes.
+ */
+
+static int bytesinpkt;		/* # of bytes in current packet */
+static char packetbuf[256];	/* workspace for accumulating packet */
+
+
+LOCAL void
+flush_packet (void)
+/* flush any accumulated data */
+{
+  if (bytesinpkt > 0) {		/* never write zero-length packet */
+    packetbuf[0] = bytesinpkt++;
+    if (fwrite(packetbuf, 1, bytesinpkt, dcinfo->output_file) != bytesinpkt)
+      ERREXIT(dcinfo->emethods, "Output file write error");
+    bytesinpkt = 0;
+  }
+}
+
+
+LOCAL void
+char_out (int c)
+/* Add a character to current packet; flush to disk if necessary */
+{
+  packetbuf[++bytesinpkt] = c;
+  if (bytesinpkt >= 255)
+    flush_packet();
+}
+
+
+/* Routine to convert variable-width codes into a byte stream */
+
+static INT32 cur_accum;		/* holds bits not yet output */
+static int cur_bits;		/* # of bits in cur_accum */
+
+
+LOCAL void
+output (code_int code)
+/* Emit a code of n_bits bits */
+/* Uses cur_accum and cur_bits to reblock into 8-bit bytes */
+{
+  if (cur_bits > 0)
+    cur_accum |= ((INT32) code << cur_bits);
+  else
+    cur_accum = code;
+  cur_bits += n_bits;
+
+  while (cur_bits >= 8) {
+    char_out((int) (cur_accum & 0xFF));
+    cur_accum >>= 8;
+    cur_bits -= 8;
+  }
+
+  /*
+   * If the next entry is going to be too big for the code size,
+   * then increase it, if possible.  We do this here to ensure
+   * that it's done in sync with the decoder's codesize increases.
+   */
+  if (free_code > maxcode) {
+    n_bits++;
+    if (n_bits == MAX_LZW_BITS)
+      maxcode = LZW_TABLE_SIZE;	/* free_code will never exceed this */
+    else
+      maxcode = MAXCODE(n_bits);
+  }
+}
+
+
+/* The LZW algorithm proper */
+
+static code_int waiting_code;	/* symbol not yet output; may be extendable */
+static boolean first_byte;	/* if TRUE, waiting_code is not valid */
+
+
+LOCAL void
+clear_hash (void)
+/* Fill the hash table with empty entries */
+{
+  /* It's sufficient to zero hash_code[] */
+  jzero_far((void FAR *) hash_code, HSIZE * SIZEOF(code_int));
+}
+
+
+LOCAL void
+clear_block (void)
+/* Reset compressor and issue a Clear code */
+{
+  clear_hash();			/* delete all the symbols */
+  free_code = ClearCode + 2;
+  output(ClearCode);		/* inform decoder */
+  n_bits = init_bits;		/* reset code size */
+  maxcode = MAXCODE(n_bits);
+}
+
+
+LOCAL void
+compress_init (int i_bits)
+/* Initialize LZW compressor */
+{
+  /* init all the static variables */
+  n_bits = init_bits = i_bits;
+  maxcode = MAXCODE(n_bits);
+  ClearCode = ((code_int) 1 << (init_bits - 1));
+  EOFCode = ClearCode + 1;
+  free_code = ClearCode + 2;
+  first_byte = TRUE;		/* no waiting symbol yet */
+  /* init output buffering vars */
+  bytesinpkt = 0;
+  cur_accum = 0;
+  cur_bits = 0;
+  /* clear hash table */
+  clear_hash();
+  /* GIF specifies an initial Clear code */
+  output(ClearCode);
+}
+
+
+LOCAL void
+compress_byte (int c)
+/* Accept and compress one 8-bit byte */
+{
+  register hash_int i;
+  register hash_int disp;
+
+  if (first_byte) {		/* need to initialize waiting_code */
+    waiting_code = c;
+    first_byte = FALSE;
+    return;
+  }
+
+  /* Probe hash table to see if a symbol exists for
+   * waiting_code followed by c.
+   * If so, replace waiting_code by that symbol and return.
+   */
+  i = ((hash_int) c << (MAX_LZW_BITS-8)) + waiting_code;
+  /* i is less than twice 2**MAX_LZW_BITS, therefore less than twice HSIZE */
+  if (i >= HSIZE)
+    i -= HSIZE;
+  
+  if (hash_code[i] != 0) {	/* is first probed slot empty? */
+    if (hash_prefix[i] == waiting_code && hash_suffix[i] == c) {
+      waiting_code = hash_code[i];
+      return;
+    }
+    if (i == 0)			/* secondary hash (after G. Knott) */
+      disp = 1;
+    else
+      disp = HSIZE - i;
+    while (1) {
+      i -= disp;
+      if (i < 0)
+	i += HSIZE;
+      if (hash_code[i] == 0)
+	break;			/* hit empty slot */
+      if (hash_prefix[i] == waiting_code && hash_suffix[i] == c) {
+	waiting_code = hash_code[i];
+	return;
+      }
+    }
+  }
+
+  /* here when hashtable[i] is an empty slot; desired symbol not in table */
+  output(waiting_code);
+  if (free_code < LZW_TABLE_SIZE) {
+    hash_code[i] = free_code++;	/* add symbol to hashtable */
+    hash_prefix[i] = waiting_code;
+    hash_suffix[i] = c;
+  } else
+    clear_block();
+  waiting_code = c;
+}
+
+
+LOCAL void
+compress_term (void)
+/* Clean up at end */
+{
+  /* Flush out the buffered code */
+  if (! first_byte)
+    output(waiting_code);
+  /* Send an EOF code */
+  output(EOFCode);
+  /* Flush the bit-packing buffer */
+  if (cur_bits > 0) {
+    char_out((int) (cur_accum & 0xFF));
+  }
+  /* Flush the packet buffer */
+  flush_packet();
+}
+
+
+/* GIF header construction */
+
+
+LOCAL void
+put_word (UINT16 w)
+/* Emit a 16-bit word, LSB first */
+{
+  putc(w & 0xFF, dcinfo->output_file);
+  putc((w >> 8) & 0xFF, dcinfo->output_file);
+}
+
+
+LOCAL void
+put_3bytes (int val)
+/* Emit 3 copies of same byte value --- handy subr for colormap construction */
+{
+  putc(val, dcinfo->output_file);
+  putc(val, dcinfo->output_file);
+  putc(val, dcinfo->output_file);
+}
+
+
+LOCAL void
+emit_header (int num_colors, JSAMPARRAY colormap)
+/* Output the GIF file header, including color map */
+/* If colormap==NULL, synthesize a gray-scale colormap */
+{
+  int BitsPerPixel, ColorMapSize, InitCodeSize, FlagByte;
+  int i;
+
+  if (num_colors > 256)
+    ERREXIT(dcinfo->emethods, "GIF can only handle 256 colors");
+  /* Compute bits/pixel and related values */
+  if (num_colors <= 2)
+    BitsPerPixel = 1;
+  else if (num_colors <= 4)
+    BitsPerPixel = 2;
+  else if (num_colors <= 8)
+    BitsPerPixel = 3;
+  else if (num_colors <= 16)
+    BitsPerPixel = 4;
+  else if (num_colors <= 32)
+    BitsPerPixel = 5;
+  else if (num_colors <= 64)
+    BitsPerPixel = 6;
+  else if (num_colors <= 128)
+    BitsPerPixel = 7;
+  else
+    BitsPerPixel = 8;
+  ColorMapSize = 1 << BitsPerPixel;
+  if (BitsPerPixel <= 1)
+    InitCodeSize = 2;
+  else
+    InitCodeSize = BitsPerPixel;
+  /*
+   * Write the GIF header.
+   * Note that we generate a plain GIF87 header for maximum compatibility.
+   */
+  fwrite("GIF87a", 1, 6, dcinfo->output_file);
+  /* Write the Logical Screen Descriptor */
+  put_word((UINT16) dcinfo->image_width);
+  put_word((UINT16) dcinfo->image_height);
+  FlagByte = 0x80;		/* Yes, there is a global color table */
+  FlagByte |= (BitsPerPixel-1) << 4; /* color resolution */
+  FlagByte |= (BitsPerPixel-1);	/* size of global color table */
+  putc(FlagByte, dcinfo->output_file);
+  putc(0, dcinfo->output_file);	/* Background color index */
+  putc(0, dcinfo->output_file);	/* Reserved in GIF87 (aspect ratio in GIF89) */
+  /* Write the Global Color Map */
+  for (i=0; i < ColorMapSize; i++) {
+    if (i < num_colors) {
+      if (colormap != NULL) {
+	if (dcinfo->out_color_space == CS_RGB) {
+	  /* Normal case: RGB color map */
+	  putc(GETJSAMPLE(colormap[0][i]), dcinfo->output_file);
+	  putc(GETJSAMPLE(colormap[1][i]), dcinfo->output_file);
+	  putc(GETJSAMPLE(colormap[2][i]), dcinfo->output_file);
+	} else {
+	  /* Grayscale "color map": possible if quantizing grayscale image */
+	  put_3bytes(GETJSAMPLE(colormap[0][i]));
+	}
+      } else {
+	/* Create a gray-scale map of num_colors values, range 0..255 */
+	put_3bytes((i * 255 + (num_colors-1)/2) / (num_colors-1));
+      }
+    } else {
+      /* fill out the map to a power of 2 */
+      put_3bytes(0);
+    }
+  }
+  /* Write image separator and Image Descriptor */
+  putc(',', dcinfo->output_file); /* separator */
+  put_word((UINT16) 0);		/* left/top offset */
+  put_word((UINT16) 0);
+  put_word((UINT16) dcinfo->image_width); /* image size */
+  put_word((UINT16) dcinfo->image_height);
+  /* flag byte: not interlaced, no local color map */
+  putc(0x00, dcinfo->output_file);
+  /* Write Initial Code Size byte */
+  putc(InitCodeSize, dcinfo->output_file);
+
+  /* Initialize for LZW compression of image data */
+  compress_init(InitCodeSize+1);
+}
+
+
+
+/*
+ * Initialize for GIF output.
+ */
+
+METHODDEF void
+output_init (decompress_info_ptr cinfo)
+{
+  dcinfo = cinfo;		/* save for use by local routines */
+  if (cinfo->final_out_comps != 1) /* safety check */
+    ERREXIT(cinfo->emethods, "GIF output got confused");
+  /* Allocate space for hash table */
+  hash_code = (code_int FAR *) (*cinfo->emethods->alloc_medium)
+				(HSIZE * SIZEOF(code_int));
+  hash_prefix = (code_int FAR *) (*cinfo->emethods->alloc_medium)
+				(HSIZE * SIZEOF(code_int));
+  hash_suffix = (UINT8 FAR *) (*cinfo->emethods->alloc_medium)
+				(HSIZE * SIZEOF(UINT8));
+  /*
+   * If we aren't quantizing, put_color_map won't be called,
+   * so emit the header now.  This only happens with gray scale output.
+   * (If we are quantizing, wait for the color map to be provided.)
+   */
+  if (! cinfo->quantize_colors)
+    emit_header(256, (JSAMPARRAY) NULL);
+}
+
+
+/*
+ * Write the color map.
+ */
+
+METHODDEF void
+put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
+{
+  emit_header(num_colors, colormap);
+}
+
+
+/*
+ * Write some pixel data.
+ */
+
+METHODDEF void
+put_pixel_rows (decompress_info_ptr cinfo, int num_rows,
+		JSAMPIMAGE pixel_data)
+{
+  register JSAMPROW ptr;
+  register long col;
+  register long width = cinfo->image_width;
+  register int row;
+  
+  for (row = 0; row < num_rows; row++) {
+    ptr = pixel_data[0][row];
+    for (col = width; col > 0; col--) {
+      compress_byte(GETJSAMPLE(*ptr));
+      ptr++;
+    }
+  }
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+output_term (decompress_info_ptr cinfo)
+{
+  /* Flush LZW mechanism */
+  compress_term();
+  /* Write a zero-length data block to end the series */
+  putc(0, cinfo->output_file);
+  /* Write the GIF terminator mark */
+  putc(';', cinfo->output_file);
+  /* Make sure we wrote the output file OK */
+  fflush(cinfo->output_file);
+  if (ferror(cinfo->output_file))
+    ERREXIT(cinfo->emethods, "Output file write error");
+  /* Free space */
+  (*cinfo->emethods->free_medium) ((void FAR *) hash_code);
+  (*cinfo->emethods->free_medium) ((void FAR *) hash_prefix);
+  (*cinfo->emethods->free_medium) ((void FAR *) hash_suffix);
+}
+
+
+/*
+ * The method selection routine for GIF format output.
+ * This should be called from d_ui_method_selection if GIF output is wanted.
+ */
+
+GLOBAL void
+jselwgif (decompress_info_ptr cinfo)
+{
+  cinfo->methods->output_init = output_init;
+  cinfo->methods->put_color_map = put_color_map;
+  cinfo->methods->put_pixel_rows = put_pixel_rows;
+  cinfo->methods->output_term = output_term;
+
+  if (cinfo->out_color_space != CS_GRAYSCALE &&
+      cinfo->out_color_space != CS_RGB)
+    ERREXIT(cinfo->emethods, "GIF output must be grayscale or RGB");
+
+  /* Force quantization if color or if > 8 bits input */
+  if (cinfo->out_color_space == CS_RGB || cinfo->data_precision > 8) {
+    /* Force quantization to at most 256 colors */
+    cinfo->quantize_colors = TRUE;
+    if (cinfo->desired_number_of_colors > 256)
+      cinfo->desired_number_of_colors = 256;
+  }
+}
+
+#endif /* GIF_SUPPORTED */
diff --git a/jwrjfif.c b/jwrjfif.c
new file mode 100644
index 0000000..cc379ac
--- /dev/null
+++ b/jwrjfif.c
@@ -0,0 +1,468 @@
+/*
+ * jwrjfif.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to write standard JPEG file headers/markers.
+ * The file format created is a raw JPEG data stream with (optionally) an
+ * APP0 marker per the JFIF spec.  This will handle baseline and
+ * JFIF-convention JPEG files, although there is currently no provision
+ * for inserting a thumbnail image in the JFIF header.
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume output to
+ * an ordinary stdio stream.  However, the changes to write to something
+ * else are localized in the macros appearing just below.
+ *
+ * These routines are invoked via the methods write_file_header,
+ * write_scan_header, write_jpeg_data, write_scan_trailer, and
+ * write_file_trailer.
+ */
+
+#include "jinclude.h"
+
+#ifdef JFIF_SUPPORTED
+
+
+/*
+ * To output to something other than a stdio stream, you'd need to redefine
+ * these macros.
+ */
+
+/* Write a single byte */
+#define emit_byte(cinfo,x)  putc((x), cinfo->output_file)
+
+/* Write some bytes from a (char *) buffer */
+#define WRITE_BYTES(cinfo,dataptr,datacount)  \
+  { if (fwrite((dataptr), 1, (datacount), cinfo->output_file) != (datacount)) \
+      ERREXIT(cinfo->emethods, "Output file write error"); }
+
+/* Clean up and verify successful output */
+#define CHECK_OUTPUT(cinfo)  \
+  { fflush(cinfo->output_file); \
+    if (ferror(cinfo->output_file)) \
+      ERREXIT(cinfo->emethods, "Output file write error"); }
+
+
+/* End of stdio-specific code. */
+
+
+typedef enum {			/* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+  
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+  
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+  
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+  
+  M_DHT   = 0xc4,
+  
+  M_DAC   = 0xcc,
+  
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+  
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+  
+  M_APP0  = 0xe0,
+  M_APP15 = 0xef,
+  
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+  
+  M_TEM   = 0x01,
+  
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+LOCAL void
+emit_marker (compress_info_ptr cinfo, JPEG_MARKER mark)
+/* Emit a marker code */
+{
+  emit_byte(cinfo, 0xFF);
+  emit_byte(cinfo, mark);
+}
+
+
+LOCAL void
+emit_2bytes (compress_info_ptr cinfo, int value)
+/* Emit a 2-byte integer; these are always MSB first in JPEG files */
+{
+  emit_byte(cinfo, (value >> 8) & 0xFF);
+  emit_byte(cinfo, value & 0xFF);
+}
+
+
+LOCAL int
+emit_dqt (compress_info_ptr cinfo, int index)
+/* Emit a DQT marker */
+/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
+{
+  QUANT_TBL_PTR data = cinfo->quant_tbl_ptrs[index];
+  int prec = 0;
+  int i;
+  
+  for (i = 0; i < DCTSIZE2; i++) {
+    if (data[i] > 255)
+      prec = 1;
+  }
+
+  emit_marker(cinfo, M_DQT);
+  
+  emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+  
+  emit_byte(cinfo, index + (prec<<4));
+  
+  for (i = 0; i < DCTSIZE2; i++) {
+    if (prec)
+      emit_byte(cinfo, data[i] >> 8);
+    emit_byte(cinfo, data[i] & 0xFF);
+  }
+
+  return prec;
+}
+
+
+LOCAL void
+emit_dht (compress_info_ptr cinfo, int index, boolean is_ac)
+/* Emit a DHT marker */
+{
+  HUFF_TBL * htbl;
+  int length, i;
+  
+  if (is_ac) {
+    htbl = cinfo->ac_huff_tbl_ptrs[index];
+    index += 0x10;		/* output index has AC bit set */
+  } else {
+    htbl = cinfo->dc_huff_tbl_ptrs[index];
+  }
+  
+  if (! htbl->sent_table) {
+    emit_marker(cinfo, M_DHT);
+    
+    length = 0;
+    for (i = 1; i <= 16; i++)
+      length += htbl->bits[i];
+    
+    emit_2bytes(cinfo, length + 2 + 1 + 16);
+    emit_byte(cinfo, index);
+    
+    for (i = 1; i <= 16; i++)
+      emit_byte(cinfo, htbl->bits[i]);
+    
+    for (i = 0; i < length; i++)
+      emit_byte(cinfo, htbl->huffval[i]);
+    
+    htbl->sent_table = TRUE;
+  }
+}
+
+
+LOCAL void
+emit_dac (compress_info_ptr cinfo)
+/* Emit a DAC marker */
+/* Since the useful info is so small, we want to emit all the tables in */
+/* one DAC marker.  Therefore this routine does its own scan of the table. */
+{
+  char dc_in_use[NUM_ARITH_TBLS];
+  char ac_in_use[NUM_ARITH_TBLS];
+  int length, i;
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    dc_in_use[i] = ac_in_use[i] = 0;
+  
+  for (i = 0; i < cinfo->num_components; i++) {
+    dc_in_use[cinfo->comp_info[i].dc_tbl_no] = 1;
+    ac_in_use[cinfo->comp_info[i].ac_tbl_no] = 1;
+  }
+  
+  length = 0;
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    length += dc_in_use[i] + ac_in_use[i];
+  
+  emit_marker(cinfo, M_DAC);
+  
+  emit_2bytes(cinfo, length*2 + 2);
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    if (dc_in_use[i]) {
+      emit_byte(cinfo, i);
+      emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
+    }
+    if (ac_in_use[i]) {
+      emit_byte(cinfo, i + 0x10);
+      emit_byte(cinfo, cinfo->arith_ac_K[i]);
+    }
+  }
+}
+
+
+LOCAL void
+emit_dri (compress_info_ptr cinfo)
+/* Emit a DRI marker */
+{
+  emit_marker(cinfo, M_DRI);
+  
+  emit_2bytes(cinfo, 4);	/* fixed length */
+
+  emit_2bytes(cinfo, (int) cinfo->restart_interval);
+}
+
+
+LOCAL void
+emit_sof (compress_info_ptr cinfo, JPEG_MARKER code)
+/* Emit a SOF marker */
+{
+  int i;
+  
+  emit_marker(cinfo, code);
+  
+  emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
+
+  emit_byte(cinfo, cinfo->data_precision);
+  emit_2bytes(cinfo, (int) cinfo->image_height);
+  emit_2bytes(cinfo, (int) cinfo->image_width);
+
+  emit_byte(cinfo, cinfo->num_components);
+
+  for (i = 0; i < cinfo->num_components; i++) {
+    emit_byte(cinfo, cinfo->comp_info[i].component_id);
+    emit_byte(cinfo, (cinfo->comp_info[i].h_samp_factor << 4)
+		     + cinfo->comp_info[i].v_samp_factor);
+    emit_byte(cinfo, cinfo->comp_info[i].quant_tbl_no);
+  }
+}
+
+
+LOCAL void
+emit_sos (compress_info_ptr cinfo)
+/* Emit a SOS marker */
+{
+  int i;
+  
+  emit_marker(cinfo, M_SOS);
+  
+  emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
+  
+  emit_byte(cinfo, cinfo->comps_in_scan);
+  
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    emit_byte(cinfo, cinfo->cur_comp_info[i]->component_id);
+    emit_byte(cinfo, (cinfo->cur_comp_info[i]->dc_tbl_no << 4)
+		     + cinfo->cur_comp_info[i]->ac_tbl_no);
+  }
+
+  emit_byte(cinfo, 0);		/* Spectral selection start */
+  emit_byte(cinfo, DCTSIZE2-1);	/* Spectral selection end */
+  emit_byte(cinfo, 0);		/* Successive approximation */
+}
+
+
+LOCAL void
+emit_jfif_app0 (compress_info_ptr cinfo)
+/* Emit a JFIF-compliant APP0 marker */
+{
+  /*
+   * Length of APP0 block	(2 bytes)
+   * Block ID			(4 bytes - ASCII "JFIF")
+   * Zero byte			(1 byte to terminate the ID string)
+   * Version Major, Minor	(2 bytes - 0x01, 0x01)
+   * Units			(1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+   * Xdpu			(2 bytes - dots per unit horizontal)
+   * Ydpu			(2 bytes - dots per unit vertical)
+   * Thumbnail X size		(1 byte)
+   * Thumbnail Y size		(1 byte)
+   */
+  
+  emit_marker(cinfo, M_APP0);
+  
+  emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
+
+  emit_byte(cinfo, 'J');	/* Identifier */
+  emit_byte(cinfo, 'F');
+  emit_byte(cinfo, 'I');
+  emit_byte(cinfo, 'F');
+  emit_byte(cinfo, 0);
+  emit_byte(cinfo, 1);		/* Major version */
+  emit_byte(cinfo, 1);		/* Minor version */
+  emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
+  emit_2bytes(cinfo, (int) cinfo->X_density);
+  emit_2bytes(cinfo, (int) cinfo->Y_density);
+  emit_byte(cinfo, 0);		/* No thumbnail image */
+  emit_byte(cinfo, 0);
+}
+
+
+/*
+ * Write the file header.
+ */
+
+
+METHODDEF void
+write_file_header (compress_info_ptr cinfo)
+{
+  char qt_in_use[NUM_QUANT_TBLS];
+  int i, prec;
+  boolean is_baseline;
+  
+  emit_marker(cinfo, M_SOI);	/* first the SOI */
+
+  if (cinfo->write_JFIF_header)	/* next an optional JFIF APP0 */
+    emit_jfif_app0(cinfo);
+
+  /* Emit DQT for each quantization table. */
+  /* Note that doing it here means we can't adjust the QTs on-the-fly. */
+  /* If we did want to do that, we'd have a problem with checking precision */
+  /* for the is_baseline determination. */
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    qt_in_use[i] = 0;
+
+  for (i = 0; i < cinfo->num_components; i++)
+    qt_in_use[cinfo->comp_info[i].quant_tbl_no] = 1;
+
+  prec = 0;
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if (qt_in_use[i])
+      prec += emit_dqt(cinfo, i);
+  }
+  /* now prec is nonzero iff there are any 16-bit quant tables. */
+
+  if (cinfo->restart_interval)
+    emit_dri(cinfo);
+
+  /* Check for a non-baseline specification. */
+  /* Note we assume that Huffman table numbers won't be changed later. */
+  is_baseline = TRUE;
+  if (cinfo->arith_code || (cinfo->data_precision != 8))
+    is_baseline = FALSE;
+  for (i = 0; i < cinfo->num_components; i++) {
+    if (cinfo->comp_info[i].dc_tbl_no > 1 || cinfo->comp_info[i].ac_tbl_no > 1)
+      is_baseline = FALSE;
+  }
+  if (prec && is_baseline) {
+    is_baseline = FALSE;
+    /* If it's baseline except for quantizer size, warn the user */
+    TRACEMS(cinfo->emethods, 0,
+	    "Caution: quantization tables are too coarse for baseline JPEG");
+  }
+
+
+  /* Emit the proper SOF marker */
+  if (cinfo->arith_code)
+    emit_sof(cinfo, M_SOF9);	/* SOF code for arithmetic coding */
+  else if (is_baseline)
+    emit_sof(cinfo, M_SOF0);	/* SOF code for baseline implementation */
+  else
+    emit_sof(cinfo, M_SOF1);	/* SOF code for non-baseline Huffman file */
+}
+
+
+/*
+ * Write the start of a scan (everything through the SOS marker).
+ */
+
+METHODDEF void
+write_scan_header (compress_info_ptr cinfo)
+{
+  int i;
+
+  if (cinfo->arith_code) {
+    /* Emit arith conditioning info.  We will have some duplication
+     * if the file has multiple scans, but it's so small it's hardly
+     * worth worrying about.
+     */
+    emit_dac(cinfo);
+  } else {
+    /* Emit Huffman tables.  Note that emit_dht takes care of
+     * suppressing duplicate tables.
+     */
+    for (i = 0; i < cinfo->comps_in_scan; i++) {
+      emit_dht(cinfo, cinfo->cur_comp_info[i]->dc_tbl_no, FALSE);
+      emit_dht(cinfo, cinfo->cur_comp_info[i]->ac_tbl_no, TRUE);
+    }
+  }
+
+  emit_sos(cinfo);
+}
+
+
+/*
+ * Write some bytes of compressed data within a scan.
+ */
+
+METHODDEF void
+write_jpeg_data (compress_info_ptr cinfo, char *dataptr, int datacount)
+{
+  WRITE_BYTES(cinfo, dataptr, datacount);
+}
+
+
+/*
+ * Finish up after a compressed scan (series of write_jpeg_data calls).
+ */
+
+METHODDEF void
+write_scan_trailer (compress_info_ptr cinfo)
+{
+  /* no work needed in this format */
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+write_file_trailer (compress_info_ptr cinfo)
+{
+  emit_marker(cinfo, M_EOI);
+  /* Make sure we wrote the output file OK */
+  CHECK_OUTPUT(cinfo);
+}
+
+
+/*
+ * The method selection routine for standard JPEG header writing.
+ * This should be called from c_ui_method_selection if appropriate.
+ */
+
+GLOBAL void
+jselwjfif (compress_info_ptr cinfo)
+{
+  cinfo->methods->write_file_header = write_file_header;
+  cinfo->methods->write_scan_header = write_scan_header;
+  cinfo->methods->write_jpeg_data = write_jpeg_data;
+  cinfo->methods->write_scan_trailer = write_scan_trailer;
+  cinfo->methods->write_file_trailer = write_file_trailer;
+}
+
+#endif /* JFIF_SUPPORTED */
diff --git a/jwrppm.c b/jwrppm.c
new file mode 100644
index 0000000..41687fe
--- /dev/null
+++ b/jwrppm.c
@@ -0,0 +1,167 @@
+/*
+ * jwrppm.c
+ *
+ * Copyright (C) 1991, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to write output images in PPM format.
+ * The PBMPLUS library is required (well, it will be in the real version).
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume output to
+ * an ordinary stdio stream.
+ *
+ * These routines are invoked via the methods put_pixel_rows, put_color_map,
+ * and output_init/term.
+ */
+
+#include "jinclude.h"
+
+#ifdef PPM_SUPPORTED
+
+
+static JSAMPARRAY color_map;	/* saves color map passed by quantizer */
+
+
+/*
+ * Write the file header.
+ */
+
+METHODDEF void
+output_init (decompress_info_ptr cinfo)
+{
+  if (cinfo->out_color_space == CS_GRAYSCALE) {
+    /* emit header for raw PGM format */
+    fprintf(cinfo->output_file, "P5\n%ld %ld\n%d\n",
+	    cinfo->image_width, cinfo->image_height, 255);
+  } else if (cinfo->out_color_space == CS_RGB) {
+    /* emit header for raw PPM format */
+    fprintf(cinfo->output_file, "P6\n%ld %ld\n%d\n",
+	    cinfo->image_width, cinfo->image_height, 255);
+  } else {
+    ERREXIT(cinfo->emethods, "PPM output must be grayscale or RGB");
+  }
+}
+
+
+/*
+ * Write some pixel data.
+ */
+
+METHODDEF void
+put_pixel_rows (decompress_info_ptr cinfo, int num_rows,
+		JSAMPIMAGE pixel_data)
+{
+  register FILE * outfile = cinfo->output_file;
+  register JSAMPROW ptr0, ptr1, ptr2;
+  register long col;
+  register long width = cinfo->image_width;
+  register int row;
+  
+  if (cinfo->out_color_space == CS_GRAYSCALE) {
+    for (row = 0; row < num_rows; row++) {
+      ptr0 = pixel_data[0][row];
+      for (col = width; col > 0; col--) {
+	putc(GETJSAMPLE(*ptr0), outfile);
+	ptr0++;
+      }
+    }
+  } else {
+    for (row = 0; row < num_rows; row++) {
+      ptr0 = pixel_data[0][row];
+      ptr1 = pixel_data[1][row];
+      ptr2 = pixel_data[2][row];
+      for (col = width; col > 0; col--) {
+	putc(GETJSAMPLE(*ptr0), outfile);
+	ptr0++;
+	putc(GETJSAMPLE(*ptr1), outfile);
+	ptr1++;
+	putc(GETJSAMPLE(*ptr2), outfile);
+	ptr2++;
+      }
+    }
+  }
+}
+
+
+/*
+ * Write some pixel data when color quantization is in effect.
+ */
+
+METHODDEF void
+put_demapped_rows (decompress_info_ptr cinfo, int num_rows,
+		   JSAMPIMAGE pixel_data)
+{
+  register FILE * outfile = cinfo->output_file;
+  register JSAMPROW ptr;
+  register long col;
+  register long width = cinfo->image_width;
+  register int row;
+  
+  if (cinfo->out_color_space == CS_GRAYSCALE) {
+    for (row = 0; row < num_rows; row++) {
+      ptr = pixel_data[0][row];
+      for (col = width; col > 0; col--) {
+	putc(GETJSAMPLE(color_map[0][GETJSAMPLE(*ptr)]), outfile);
+	ptr++;
+      }
+    }
+  } else {
+    for (row = 0; row < num_rows; row++) {
+      ptr = pixel_data[0][row];
+      for (col = width; col > 0; col--) {
+	register int pixval = GETJSAMPLE(*ptr);
+
+	putc(GETJSAMPLE(color_map[0][pixval]), outfile);
+	putc(GETJSAMPLE(color_map[1][pixval]), outfile);
+	putc(GETJSAMPLE(color_map[2][pixval]), outfile);
+	ptr++;
+      }
+    }
+  }
+}
+
+
+/*
+ * Write the color map.
+ * For PPM output, we just demap the output data!
+ */
+
+METHODDEF void
+put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
+{
+  color_map = colormap;		/* save for use in output */
+  cinfo->methods->put_pixel_rows = put_demapped_rows;
+}
+
+
+/*
+ * Finish up at the end of the file.
+ */
+
+METHODDEF void
+output_term (decompress_info_ptr cinfo)
+{
+  /* No work except to make sure we wrote the output file OK */
+  fflush(cinfo->output_file);
+  if (ferror(cinfo->output_file))
+    ERREXIT(cinfo->emethods, "Output file write error");
+}
+
+
+/*
+ * The method selection routine for PPM format output.
+ * This should be called from d_ui_method_selection if PPM output is wanted.
+ */
+
+GLOBAL void
+jselwppm (decompress_info_ptr cinfo)
+{
+  cinfo->methods->output_init = output_init;
+  cinfo->methods->put_color_map = put_color_map;
+  cinfo->methods->put_pixel_rows = put_pixel_rows;
+  cinfo->methods->output_term = output_term;
+}
+
+#endif /* PPM_SUPPORTED */
diff --git a/makcjpeg.cf b/makcjpeg.cf
new file mode 100644
index 0000000..ea93ce4
--- /dev/null
+++ b/makcjpeg.cf
@@ -0,0 +1,5 @@
+L jcmain.mix jerror.mix jcdeflts.mix jrdgif.mix jrdppm.mix jwrjfif.mix
+L jcarith.mix jccolor.mix jcexpand.mix jchuff.mix jcmaster.mix jcmcu.mix
+L jcpipe.mix jcsample.mix jfwddct.mix jutils.mix jvirtmem.mix
+fa;
+b cjpeg,8K,48K,
diff --git a/makcjpeg.lnk b/makcjpeg.lnk
new file mode 100644
index 0000000..23702b2
--- /dev/null
+++ b/makcjpeg.lnk
@@ -0,0 +1,21 @@
+jcmain.obj +
+jerror.obj +
+jcdeflts.obj +
+jrdgif.obj +
+jrdppm.obj +
+jwrjfif.obj +
+jcarith.obj +
+jccolor.obj +
+jcexpand.obj +
+jchuff.obj +
+jcmaster.obj +
+jcmcu.obj +
+jcpipe.obj +
+jcsample.obj +
+jfwddct.obj +
+jutils.obj +
+jvirtmem.obj
+cjpeg.exe /NOI
+nul.map
+
+nul.def
diff --git a/makdjpeg.cf b/makdjpeg.cf
new file mode 100644
index 0000000..968af31
--- /dev/null
+++ b/makdjpeg.cf
@@ -0,0 +1,6 @@
+L jdmain.mix jerror.mix jrdjfif.mix jwrgif.mix jwrppm.mix
+L jbsmooth.mix jdarith.mix jdcolor.mix jdhuff.mix jdmaster.mix jdmcu.mix
+L jdpipe.mix jdsample.mix jquant1.mix jquant2.mix jrevdct.mix jutils.mix
+L jvirtmem.mix
+fa;
+b djpeg,8K,48K,
diff --git a/makdjpeg.lnk b/makdjpeg.lnk
new file mode 100644
index 0000000..6e9107c
--- /dev/null
+++ b/makdjpeg.lnk
@@ -0,0 +1,22 @@
+jdmain.obj +
+jerror.obj +
+jrdjfif.obj +
+jwrgif.obj +
+jwrppm.obj +
+jbsmooth.obj +
+jdarith.obj +
+jdcolor.obj +
+jdhuff.obj +
+jdmaster.obj +
+jdmcu.obj +
+jdpipe.obj +
+jdsample.obj +
+jquant1.obj +
+jquant2.obj +
+jrevdct.obj +
+jutils.obj +
+jvirtmem.obj /NOI
+djpeg.exe
+nul.map
+
+nul.def
diff --git a/makefile.amiga b/makefile.amiga
new file mode 100644
index 0000000..2fde93a
--- /dev/null
+++ b/makefile.amiga
@@ -0,0 +1,143 @@
+# Makefile for Independent JPEG Group's software
+
+# This makefile is suitable for Amiga systems using Manx Aztec C ver 5.x.
+# Thanks to D.J. James for this version.
+
+# See README and edit jconfig.h before saying "make" !!
+
+CC= cc
+
+# You may need to adjust these cc options:
+CFLAGS= -MC -MD -DTWO_FILE_COMMANDLINE
+LDFLAGS=
+LDLIBS= -lml -lcl
+
+# miscellaneous OS-dependent stuff
+LN= ln		# linker
+RM= delete quiet # file deletion command
+AR= lb		# library (.lib) file creation command
+
+
+# source files
+INCLUDES= jinclude.h jconfig.h jpegdata.h 
+SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c \
+	 jchuff.c jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c \
+	 jdarith.c jdcolor.c jdhuff.c jdmain.c jdmaster.c jdmcu.c \
+	 jdpipe.c jdsample.c jerror.c jfwddct.c jquant1.c jquant2.c \
+	 jrdjfif.c jrdgif.c jrdppm.c jrevdct.c jutils.c jvirtmem.c \
+	 jwrjfif.c jwrgif.c jwrppm.c egetopt.c
+DOCS= README architecture codingrules
+MAKEFILES= makefile.unix makefile.amiga \
+	   makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk \
+	   makefile.pwc makcjpeg.cf makdjpeg.cf makljpeg.cf
+TESTFILES= testorig.jpg testimg.ppm testimg.jpg
+DISTFILES= $(DOCS) $(MAKEFILES) ansi2knr.c $(SOURCES) $(INCLUDES) $(TESTFILES)
+
+# compression objectfiles
+COBJECTS = jcmain.o jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o \
+	   jchuff.o jcmcu.o jcpipe.o jcsample.o jfwddct.o \
+	   jrdgif.o jrdppm.o jwrjfif.o \
+	   jutils.o jvirtmem.o jerror.o
+# decompression objectfiles
+DOBJECTS = jdmain.o jdmaster.o jbsmooth.o jdarith.o jdcolor.o jdhuff.o \
+	   jdmcu.o jdpipe.o jdsample.o jquant1.o jquant2.o jrevdct.o \
+	   jrdjfif.o jwrgif.o jwrppm.o \
+	   jutils.o jvirtmem.o jerror.o
+# These objectfiles are included in libjpeg.lib (all but jcmain.o, jdmain.o)
+LIBOBJECTS = jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o \
+	     jchuff.o jcmcu.o jcpipe.o jcsample.o jfwddct.o \
+	     jrdgif.o jrdppm.o jwrjfif.o \
+	     jdmaster.o jbsmooth.o jdarith.o jdcolor.o jdhuff.o \
+	     jdmcu.o jdpipe.o jdsample.o jquant1.o jquant2.o jrevdct.o \
+	     jrdjfif.o jwrgif.o jwrppm.o \
+	     jutils.o jvirtmem.o jerror.o
+
+
+all: cjpeg djpeg
+# By default, libjpeg.lib is not built unless you explicitly request it.
+
+
+# If you have a C compiler that doesn't understand function prototypes,
+# uncomment the 5 lines below and make sure PROTO is not defined by jconfig.h.
+# Then say "make ansi2knr" before "make".
+
+#.c.o:
+#	./ansi2knr $*.c tmpansi.c
+#	$(CC) $(CFLAGS) -c tmpansi.c
+#	mv tmpansi.o $*.o
+#	$(RM) tmpansi.c
+
+ansi2knr: ansi2knr.c
+	$(CC) -o ansi2knr ansi2knr.c
+# You may need to add one of -DBSD, -DVMS, or -DMSDOS to the line above.
+
+
+cjpeg: $(COBJECTS)
+	$(LN) $(LDFLAGS) -o cjpeg $(COBJECTS) $(LDLIBS)
+
+djpeg: $(DOBJECTS)
+	$(LN) $(LDFLAGS) -o djpeg $(DOBJECTS) $(LDLIBS)
+
+# libjpeg.lib is useful if you are including the JPEG software in a larger
+# program; you'd include it in your link, rather than the individual modules.
+libjpeg.lib: $(LIBOBJECTS)
+	-$(RM) libjpeg.lib
+	$(AR) libjpeg.lib  $(LIBOBJECTS)
+
+# Use the following to test the built library
+#cjpeg: jcmain.o libjpeg.lib
+#	$(LN) $(LDFLAGS) -o cjpeg jcmain.o -llibjpeg $(LDLIBS)
+#
+#djpeg: jdmain.o libjpeg.lib
+#	$(LN) $(LDFLAGS) -o djpeg jdmain.o -llibjpeg $(LDLIBS)
+
+clean:
+	-$(RM) *.o cjpeg djpeg libjpeg.lib ansi2knr core tmpansi.* testout.ppm testout.jpg
+
+distribute:
+	-$(RM) jpegsrc.tar*
+	tar cvf jpegsrc.tar $(DISTFILES)
+	list jpegsrc.tar
+	compress -v jpegsrc.tar
+	list jpegsrc.tar*
+
+test: cjpeg djpeg
+	-$(RM) testout.ppm testout.jpg
+	./djpeg testorig.jpg testout.ppm
+	./cjpeg testimg.ppm testout.jpg
+	cmp testimg.ppm testout.ppm
+	cmp testimg.jpg testout.jpg
+
+
+jbsmooth.o : jbsmooth.c jinclude.h jconfig.h jpegdata.h 
+jcarith.o : jcarith.c jinclude.h jconfig.h jpegdata.h 
+jccolor.o : jccolor.c jinclude.h jconfig.h jpegdata.h 
+jcdeflts.o : jcdeflts.c jinclude.h jconfig.h jpegdata.h 
+jcexpand.o : jcexpand.c jinclude.h jconfig.h jpegdata.h 
+jchuff.o : jchuff.c jinclude.h jconfig.h jpegdata.h 
+jcmain.o : jcmain.c jinclude.h jconfig.h jpegdata.h egetopt.c 
+jcmaster.o : jcmaster.c jinclude.h jconfig.h jpegdata.h 
+jcmcu.o : jcmcu.c jinclude.h jconfig.h jpegdata.h 
+jcpipe.o : jcpipe.c jinclude.h jconfig.h jpegdata.h 
+jcsample.o : jcsample.c jinclude.h jconfig.h jpegdata.h 
+jdarith.o : jdarith.c jinclude.h jconfig.h jpegdata.h 
+jdcolor.o : jdcolor.c jinclude.h jconfig.h jpegdata.h 
+jdhuff.o : jdhuff.c jinclude.h jconfig.h jpegdata.h 
+jdmain.o : jdmain.c jinclude.h jconfig.h jpegdata.h egetopt.c
+jdmaster.o : jdmaster.c jinclude.h jconfig.h jpegdata.h 
+jdmcu.o : jdmcu.c jinclude.h jconfig.h jpegdata.h 
+jdpipe.o : jdpipe.c jinclude.h jconfig.h jpegdata.h 
+jdsample.o : jdsample.c jinclude.h jconfig.h jpegdata.h 
+jerror.o : jerror.c jinclude.h jconfig.h jpegdata.h 
+jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h 
+jquant1.o : jquant1.c jinclude.h jconfig.h jpegdata.h 
+jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h 
+jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h 
+jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h 
+jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h 
+jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h 
+jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h 
+jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h 
+jwrjfif.o : jwrjfif.c jinclude.h jconfig.h jpegdata.h 
+jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h 
+jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h 
diff --git a/makefile.mc5 b/makefile.mc5
new file mode 100644
index 0000000..eee9f21
--- /dev/null
+++ b/makefile.mc5
@@ -0,0 +1,115 @@
+# Makefile for Independent JPEG Group's software
+
+# This makefile is for Microsoft C for MS-DOS, version 5.x.
+
+# See README and edit jconfig.h before saying "make" !!
+
+# Microsoft's brain-damaged version of make uses nonstandard syntax (a blank
+# line is needed to terminate a command list) and it simply scans the rules
+# in order, rather than doing a true dependency-tree walk.  Furthermore,
+# expanded command lines can't exceed 128 chars (this is a DOS bug, not
+# make's fault); so we can't just name all the objectfiles in the link steps.
+# Instead we shove each objectfile into a library as it is made, and link
+# from the library.  The objectfiles are also kept separately as timestamps.
+
+# You may need to adjust these cc options:
+CFLAGS=  /AS /I. /W3 /Oail /Gs /DMEM_STATS  # NB: /Gs turns off stack oflo checks
+LDFLAGS= /Fm /F 2000  # /F hhhh  sets stack size (in hex)
+# In particular:
+#   Add /DMSDOS if your compiler doesn't automatically #define MSDOS.
+#   Add /DHAVE_GETOPT if your library includes getopt(3) (see jcmain.c, jdmain.c).
+#   /DMEM_STATS is optional -- it enables gathering of memory usage statistics.
+
+# compression objectfiles
+COBJECTS = jcmain.obj jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj \
+	   jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj \
+	   jrdgif.obj jrdppm.obj jwrjfif.obj \
+	   jutils.obj jvirtmem.obj jerror.obj
+# decompression objectfiles
+DOBJECTS = jdmain.obj jdmaster.obj jbsmooth.obj jdarith.obj jdcolor.obj jdhuff.obj \
+	   jdmcu.obj jdpipe.obj jdsample.obj jquant1.obj jquant2.obj jrevdct.obj \
+	   jrdjfif.obj jwrgif.obj jwrppm.obj \
+	   jutils.obj jvirtmem.obj jerror.obj
+
+
+# inference rule used for all compilations except jcmain.c, jdmain.c
+# notice that objectfile is also inserted into libjpeg.lib
+.c.obj:
+	cl $(CFLAGS) /c $*.c
+	lib libjpeg -+$*.obj;
+
+# these two objectfiles are not inserted into libjpeg
+# because they have duplicate global symbol names (notably main()).
+jcmain.obj: jcmain.c jinclude.h jconfig.h jpegdata.h egetopt.c 
+	cl $(CFLAGS) /c $*.c
+
+jdmain.obj: jdmain.c jinclude.h jconfig.h jpegdata.h egetopt.c
+	cl $(CFLAGS) /c $*.c
+
+
+jbsmooth.obj: jbsmooth.c jinclude.h jconfig.h jpegdata.h 
+
+jcarith.obj: jcarith.c jinclude.h jconfig.h jpegdata.h 
+
+jccolor.obj: jccolor.c jinclude.h jconfig.h jpegdata.h 
+
+jcdeflts.obj: jcdeflts.c jinclude.h jconfig.h jpegdata.h 
+
+jcexpand.obj: jcexpand.c jinclude.h jconfig.h jpegdata.h 
+
+jchuff.obj: jchuff.c jinclude.h jconfig.h jpegdata.h 
+
+jcmaster.obj: jcmaster.c jinclude.h jconfig.h jpegdata.h 
+
+jcmcu.obj: jcmcu.c jinclude.h jconfig.h jpegdata.h 
+
+jcpipe.obj: jcpipe.c jinclude.h jconfig.h jpegdata.h 
+
+jcsample.obj: jcsample.c jinclude.h jconfig.h jpegdata.h 
+
+jdarith.obj: jdarith.c jinclude.h jconfig.h jpegdata.h 
+
+jdcolor.obj: jdcolor.c jinclude.h jconfig.h jpegdata.h 
+
+jdhuff.obj: jdhuff.c jinclude.h jconfig.h jpegdata.h 
+
+jdmaster.obj: jdmaster.c jinclude.h jconfig.h jpegdata.h 
+
+jdmcu.obj: jdmcu.c jinclude.h jconfig.h jpegdata.h 
+
+jdpipe.obj: jdpipe.c jinclude.h jconfig.h jpegdata.h 
+
+jdsample.obj: jdsample.c jinclude.h jconfig.h jpegdata.h 
+
+jerror.obj: jerror.c jinclude.h jconfig.h jpegdata.h 
+
+jfwddct.obj: jfwddct.c jinclude.h jconfig.h jpegdata.h 
+
+jquant1.obj: jquant1.c jinclude.h jconfig.h jpegdata.h 
+
+jquant2.obj: jquant2.c jinclude.h jconfig.h jpegdata.h 
+
+jrdjfif.obj: jrdjfif.c jinclude.h jconfig.h jpegdata.h 
+
+jrdgif.obj: jrdgif.c jinclude.h jconfig.h jpegdata.h 
+
+jrdppm.obj: jrdppm.c jinclude.h jconfig.h jpegdata.h 
+
+jrevdct.obj: jrevdct.c jinclude.h jconfig.h jpegdata.h 
+
+jutils.obj: jutils.c jinclude.h jconfig.h jpegdata.h 
+
+jvirtmem.obj: jvirtmem.c jinclude.h jconfig.h jpegdata.h 
+
+jwrjfif.obj: jwrjfif.c jinclude.h jconfig.h jpegdata.h 
+
+jwrgif.obj: jwrgif.c jinclude.h jconfig.h jpegdata.h 
+
+jwrppm.obj: jwrppm.c jinclude.h jconfig.h jpegdata.h 
+
+
+cjpeg.exe: $(COBJECTS)
+	cl /Fecjpeg.exe jcmain.obj libjpeg.lib $(LDFLAGS)
+
+djpeg.exe: $(DOBJECTS)
+	cl /Fedjpeg.exe jdmain.obj libjpeg.lib $(LDFLAGS)
diff --git a/makefile.mc6 b/makefile.mc6
new file mode 100644
index 0000000..b9ca60f
--- /dev/null
+++ b/makefile.mc6
@@ -0,0 +1,79 @@
+# Makefile for Independent JPEG Group's software
+
+# This makefile is for Microsoft C for MS-DOS, version 6.x (use NMAKE).
+# Thanks to Alan Wright and Chris Turner of Olivetti Research Ltd.
+
+# See README and edit jconfig.h before saying "make" !!
+
+all: cjpeg.exe djpeg.exe
+
+# compiler flags. -D gives a #define to the sources:
+#       -O              default optimisation
+#       -W3             warning level 3
+#       -Za             ANSI conformance, defines__STDC__ but undefines far
+#                       and near!
+#       -D__STDC__      pretend we have full ANSI compliance. MSC is near
+#                       enough anyway
+#       -DMSDOS         we are on an MSDOS machine
+#       -DMEM_STATS     enable memory usage statistics (optional)
+#       -DHAVE_GETOPT   library has getopt routine to parse cmnd line options
+#       -c              compile, don't link (implicit in inference rules)
+
+CFLAGS = -c -O -W3 -DMSDOS -D__STDC__ -DMEM_STATS
+
+
+# compression objectfiles
+COBJECTS = jcmain.obj jcmaster.obj jcdeflts.obj jcarith.obj jccolor.obj jcexpand.obj \
+	   jchuff.obj jcmcu.obj jcpipe.obj jcsample.obj jfwddct.obj \
+	   jrdgif.obj jrdppm.obj jwrjfif.obj \
+	   jutils.obj jvirtmem.obj jerror.obj
+# decompression objectfiles
+DOBJECTS = jdmain.obj jdmaster.obj jbsmooth.obj jdarith.obj jdcolor.obj jdhuff.obj \
+	   jdmcu.obj jdpipe.obj jdsample.obj jquant1.obj jquant2.obj jrevdct.obj \
+	   jrdjfif.obj jwrgif.obj jwrppm.obj \
+	   jutils.obj jvirtmem.obj jerror.obj
+
+
+# default rules in nmake will use cflags and compile the list below
+
+jbsmooth.o : jbsmooth.c jinclude.h jconfig.h jpegdata.h 
+jcarith.o : jcarith.c jinclude.h jconfig.h jpegdata.h 
+jccolor.o : jccolor.c jinclude.h jconfig.h jpegdata.h 
+jcdeflts.o : jcdeflts.c jinclude.h jconfig.h jpegdata.h 
+jcexpand.o : jcexpand.c jinclude.h jconfig.h jpegdata.h 
+jchuff.o : jchuff.c jinclude.h jconfig.h jpegdata.h 
+jcmain.o : jcmain.c jinclude.h jconfig.h jpegdata.h egetopt.c 
+jcmaster.o : jcmaster.c jinclude.h jconfig.h jpegdata.h 
+jcmcu.o : jcmcu.c jinclude.h jconfig.h jpegdata.h 
+jcpipe.o : jcpipe.c jinclude.h jconfig.h jpegdata.h 
+jcsample.o : jcsample.c jinclude.h jconfig.h jpegdata.h 
+jdarith.o : jdarith.c jinclude.h jconfig.h jpegdata.h 
+jdcolor.o : jdcolor.c jinclude.h jconfig.h jpegdata.h 
+jdhuff.o : jdhuff.c jinclude.h jconfig.h jpegdata.h 
+jdmain.o : jdmain.c jinclude.h jconfig.h jpegdata.h egetopt.c
+jdmaster.o : jdmaster.c jinclude.h jconfig.h jpegdata.h 
+jdmcu.o : jdmcu.c jinclude.h jconfig.h jpegdata.h 
+jdpipe.o : jdpipe.c jinclude.h jconfig.h jpegdata.h 
+jdsample.o : jdsample.c jinclude.h jconfig.h jpegdata.h 
+jerror.o : jerror.c jinclude.h jconfig.h jpegdata.h 
+jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h 
+jquant1.o : jquant1.c jinclude.h jconfig.h jpegdata.h 
+jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h 
+jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h 
+jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h 
+jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h 
+jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h 
+jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h 
+jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h 
+jwrjfif.o : jwrjfif.c jinclude.h jconfig.h jpegdata.h 
+jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h 
+jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h 
+
+
+# use linker response files because file list > 128 chars
+
+cjpeg.exe: $(COBJECTS)
+        link /STACK:8192 @makcjpeg.lnk
+
+djpeg.exe: $(DOBJECTS)
+        link /STACK:8192 @makdjpeg.lnk
diff --git a/makefile.pwc b/makefile.pwc
new file mode 100644
index 0000000..f41dd48
--- /dev/null
+++ b/makefile.pwc
@@ -0,0 +1,100 @@
+# Makefile for Independent JPEG Group's software
+
+# This makefile is for Mix Software's Power C, v2.1.1
+# and Dan Grayson's pd make 2.14 under MS-DOS.
+# Thanks to Bob Hardy for this version.
+
+# See README and edit jconfig.h before saying "make" !!
+
+# NOTE: make sure you have converted end-of-line markers to CR/LF in this file
+# and in the three mak*.cf files; otherwise pd make and the Mix linker will
+# choke.  Power C doesn't seem to care whether end-of-lines are CR/LF or just
+# LF in the *.h and *.c files.  If you blindly converted LF to CR/LF in ALL
+# the files, then you broke the test*.* files, which contain binary data.
+
+CC=pc
+
+# You may need to adjust these cc options:
+MODEL=m
+CFLAGS=-dMEM_STATS -dMSDOS -m$(MODEL)
+LDFLAGS=
+# In particular:
+#   -dMEM_STATS is optional -- it enables gathering of memory usage statistics.
+LDLIBS=
+
+# miscellaneous OS-dependent stuff
+# linker
+LN=pcl
+# file deletion command
+RM=del
+# library (.mix) file creation command
+AR=merge
+
+
+# compression objectfiles
+COBJECTS = jcmain.mix jcmaster.mix jcdeflts.mix jcarith.mix jccolor.mix jcexpand.mix jchuff.mix jcmcu.mix jcpipe.mix jcsample.mix jfwddct.mix jrdgif.mix jrdppm.mix jwrjfif.mix jutils.mix jvirtmem.mix jerror.mix
+# decompression objectfiles
+DOBJECTS = jdmain.mix jdmaster.mix jbsmooth.mix jdarith.mix jdcolor.mix jdhuff.mix jdmcu.mix jdpipe.mix jdsample.mix jquant1.mix jquant2.mix jrevdct.mix jrdjfif.mix jwrgif.mix jwrppm.mix jutils.mix jvirtmem.mix jerror.mix
+# These objectfiles are included in libjpeg.mix (all but jcmain, jdmain)
+LIBOBJECTS = jcmaster.mix jcdeflts.mix jcarith.mix jccolor.mix jcexpand.mix jchuff.mix jcmcu.mix jcpipe.mix jcsample.mix jfwddct.mix jrdgif.mix jrdppm.mix jwrjfif.mix jdmaster.mix jbsmooth.mix jdarith.mix jdcolor.mix jdhuff.mix jdmcu.mix jdpipe.mix jdsample.mix jquant1.mix jquant2.mix jrevdct.mix jrdjfif.mix jwrgif.mix jwrppm.mix jutils.mix jvirtmem.mix jerror.mix
+
+
+all: cjpeg.exe djpeg.exe test
+# By default, libjpeg.mix is not built unless you explicitly request it.
+
+
+cjpeg.exe: $(COBJECTS)
+	$(LN) $(LDFLAGS) @makcjpeg.cf
+
+djpeg.exe: $(DOBJECTS)
+	$(LN) $(LDFLAGS) @makdjpeg.cf
+
+# libjpeg.mix is useful if you are including the JPEG software in a larger
+# program; you'd include it in your link, rather than the individual modules.
+libjpeg.mix: $(LIBOBJECTS)
+	@$(RM) libjpeg.mix
+	$(AR) libjpeg.mix @makljpeg.cf
+
+clean:
+	$(RM) *.mix cjpeg.exe djpeg.exe testout.*
+
+test:
+	@$(RM) testout.*
+	+djpeg testorig.jpg testout.ppm
+	+cjpeg testimg.ppm testout.jpg
+	fc testimg.ppm testout.ppm
+	fc testimg.jpg testout.jpg
+
+
+jbsmooth.mix : jbsmooth.c jinclude.h jconfig.h jpegdata.h 
+jcarith.mix : jcarith.c jinclude.h jconfig.h jpegdata.h 
+jccolor.mix : jccolor.c jinclude.h jconfig.h jpegdata.h 
+jcdeflts.mix : jcdeflts.c jinclude.h jconfig.h jpegdata.h 
+jcexpand.mix : jcexpand.c jinclude.h jconfig.h jpegdata.h 
+jchuff.mix : jchuff.c jinclude.h jconfig.h jpegdata.h 
+jcmain.mix : jcmain.c jinclude.h jconfig.h jpegdata.h egetopt.c 
+jcmaster.mix : jcmaster.c jinclude.h jconfig.h jpegdata.h 
+jcmcu.mix : jcmcu.c jinclude.h jconfig.h jpegdata.h 
+jcpipe.mix : jcpipe.c jinclude.h jconfig.h jpegdata.h 
+jcsample.mix : jcsample.c jinclude.h jconfig.h jpegdata.h 
+jdarith.mix : jdarith.c jinclude.h jconfig.h jpegdata.h 
+jdcolor.mix : jdcolor.c jinclude.h jconfig.h jpegdata.h 
+jdhuff.mix : jdhuff.c jinclude.h jconfig.h jpegdata.h 
+jdmain.mix : jdmain.c jinclude.h jconfig.h jpegdata.h egetopt.c
+jdmaster.mix : jdmaster.c jinclude.h jconfig.h jpegdata.h 
+jdmcu.mix : jdmcu.c jinclude.h jconfig.h jpegdata.h 
+jdpipe.mix : jdpipe.c jinclude.h jconfig.h jpegdata.h 
+jdsample.mix : jdsample.c jinclude.h jconfig.h jpegdata.h 
+jerror.mix : jerror.c jinclude.h jconfig.h jpegdata.h 
+jfwddct.mix : jfwddct.c jinclude.h jconfig.h jpegdata.h 
+jquant1.mix : jquant1.c jinclude.h jconfig.h jpegdata.h 
+jquant2.mix : jquant2.c jinclude.h jconfig.h jpegdata.h 
+jrdjfif.mix : jrdjfif.c jinclude.h jconfig.h jpegdata.h 
+jrdgif.mix : jrdgif.c jinclude.h jconfig.h jpegdata.h 
+jrdppm.mix : jrdppm.c jinclude.h jconfig.h jpegdata.h 
+jrevdct.mix : jrevdct.c jinclude.h jconfig.h jpegdata.h 
+jutils.mix : jutils.c jinclude.h jconfig.h jpegdata.h 
+jvirtmem.mix : jvirtmem.c jinclude.h jconfig.h jpegdata.h 
+jwrjfif.mix : jwrjfif.c jinclude.h jconfig.h jpegdata.h 
+jwrgif.mix : jwrgif.c jinclude.h jconfig.h jpegdata.h 
+jwrppm.mix : jwrppm.c jinclude.h jconfig.h jpegdata.h 
diff --git a/makefile.unix b/makefile.unix
new file mode 100644
index 0000000..0f11afa
--- /dev/null
+++ b/makefile.unix
@@ -0,0 +1,152 @@
+# Makefile for Independent JPEG Group's software
+
+# This makefile is suitable for Unix-like systems.
+
+# See README and edit jconfig.h before saying "make" !!
+
+# Comment out this line if you don't have gcc:
+CC=gcc
+
+# You may need to adjust these cc options:
+CFLAGS= -O -g -Wall -DHAVE_GETOPT -DMEM_STATS
+LDFLAGS= -g
+# In particular:
+#   Remove -g and -Wall if not using gcc.
+#   Add -DBSD if on a pure BSD system (see jinclude.h).
+#   Remove -DHAVE_GETOPT if you don't have getopt(3) (see jcmain.c, jdmain.c).
+#   -DMEM_STATS is optional -- it enables gathering of memory usage statistics.
+#   You may also want to add -DTWO_FILE_COMMANDLINE or -D switches for other
+#   symbols listed in jconfig.h, if you prefer not to change jconfig.h.
+# If your compiler is non-ANSI, also see the .c.o rule below.
+
+# On HP-UX (and probably other SysV systems) the alternate malloc(3X) is a lot
+# faster than the standard malloc; this makes a noticeable difference in the
+# startup time when handling big noninterleaved images.  I say "-lmalloc" to
+# get the alternate allocator.  On most non-SysV systems you can just
+# define LDLIBS as empty.
+LDLIBS= -lmalloc
+
+# miscellaneous OS-dependent stuff
+LN= $(CC)	# linker
+RM= rm -f	# file deletion command
+AR= ar rc	# library (.a) file creation command
+AR2= ranlib	# second step in .a creation (use "touch" if not needed)
+
+
+# source files
+INCLUDES= jinclude.h jconfig.h jpegdata.h 
+SOURCES= jbsmooth.c jcarith.c jccolor.c jcdeflts.c jcexpand.c \
+	 jchuff.c jcmain.c jcmaster.c jcmcu.c jcpipe.c jcsample.c \
+	 jdarith.c jdcolor.c jdhuff.c jdmain.c jdmaster.c jdmcu.c \
+	 jdpipe.c jdsample.c jerror.c jfwddct.c jquant1.c jquant2.c \
+	 jrdjfif.c jrdgif.c jrdppm.c jrevdct.c jutils.c jvirtmem.c \
+	 jwrjfif.c jwrgif.c jwrppm.c egetopt.c
+DOCS= README architecture codingrules
+MAKEFILES= makefile.unix makefile.amiga \
+	   makefile.mc5 makefile.mc6 makcjpeg.lnk makdjpeg.lnk \
+	   makefile.pwc makcjpeg.cf makdjpeg.cf makljpeg.cf
+TESTFILES= testorig.jpg testimg.ppm testimg.jpg
+DISTFILES= $(DOCS) $(MAKEFILES) ansi2knr.c $(SOURCES) $(INCLUDES) $(TESTFILES)
+
+# compression objectfiles
+COBJECTS = jcmain.o jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o \
+	   jchuff.o jcmcu.o jcpipe.o jcsample.o jfwddct.o \
+	   jrdgif.o jrdppm.o jwrjfif.o \
+	   jutils.o jvirtmem.o jerror.o
+# decompression objectfiles
+DOBJECTS = jdmain.o jdmaster.o jbsmooth.o jdarith.o jdcolor.o jdhuff.o \
+	   jdmcu.o jdpipe.o jdsample.o jquant1.o jquant2.o jrevdct.o \
+	   jrdjfif.o jwrgif.o jwrppm.o \
+	   jutils.o jvirtmem.o jerror.o
+# These objectfiles are included in libjpeg.a (all but jcmain.o, jdmain.o)
+LIBOBJECTS = jcmaster.o jcdeflts.o jcarith.o jccolor.o jcexpand.o \
+	     jchuff.o jcmcu.o jcpipe.o jcsample.o jfwddct.o \
+	     jrdgif.o jrdppm.o jwrjfif.o \
+	     jdmaster.o jbsmooth.o jdarith.o jdcolor.o jdhuff.o \
+	     jdmcu.o jdpipe.o jdsample.o jquant1.o jquant2.o jrevdct.o \
+	     jrdjfif.o jwrgif.o jwrppm.o \
+	     jutils.o jvirtmem.o jerror.o
+
+
+all: cjpeg djpeg
+# By default, libjpeg.a is not built unless you explicitly request it.
+
+
+# If you have a C compiler that doesn't understand function prototypes,
+# uncomment the 5 lines below and make sure PROTO is not defined by jconfig.h.
+# Then say "make ansi2knr" before "make".
+
+#.c.o:
+#	./ansi2knr $*.c tmpansi.c
+#	$(CC) $(CFLAGS) -c tmpansi.c
+#	mv tmpansi.o $*.o
+#	$(RM) tmpansi.c
+
+ansi2knr: ansi2knr.c
+	$(CC) -o ansi2knr ansi2knr.c
+# You may need to add one of -DBSD, -DVMS, or -DMSDOS to the line above.
+
+
+cjpeg: $(COBJECTS)
+	$(LN) $(LDFLAGS) -o cjpeg $(COBJECTS) $(LDLIBS)
+
+djpeg: $(DOBJECTS)
+	$(LN) $(LDFLAGS) -o djpeg $(DOBJECTS) $(LDLIBS)
+
+# libjpeg.a is useful if you are including the JPEG software in a larger
+# program; you'd include it in your link, rather than the individual modules.
+libjpeg.a: $(LIBOBJECTS)
+	$(RM) libjpeg.a
+	$(AR) libjpeg.a  $(LIBOBJECTS)
+	$(AR2) libjpeg.a
+
+clean:
+	$(RM) *.o cjpeg djpeg libjpeg.a ansi2knr core tmpansi.* testout.ppm testout.jpg
+
+distribute:
+	$(RM) jpegsrc.tar*
+	tar cvf jpegsrc.tar $(DISTFILES)
+	ls -l jpegsrc.tar
+	compress -v jpegsrc.tar
+	ls -l jpegsrc.tar*
+
+test: cjpeg djpeg
+	$(RM) testout.ppm testout.jpg
+	./djpeg testorig.jpg >testout.ppm
+	./cjpeg testimg.ppm >testout.jpg
+	cmp testimg.ppm testout.ppm
+	cmp testimg.jpg testout.jpg
+
+
+jbsmooth.o : jbsmooth.c jinclude.h jconfig.h jpegdata.h 
+jcarith.o : jcarith.c jinclude.h jconfig.h jpegdata.h 
+jccolor.o : jccolor.c jinclude.h jconfig.h jpegdata.h 
+jcdeflts.o : jcdeflts.c jinclude.h jconfig.h jpegdata.h 
+jcexpand.o : jcexpand.c jinclude.h jconfig.h jpegdata.h 
+jchuff.o : jchuff.c jinclude.h jconfig.h jpegdata.h 
+jcmain.o : jcmain.c jinclude.h jconfig.h jpegdata.h egetopt.c 
+jcmaster.o : jcmaster.c jinclude.h jconfig.h jpegdata.h 
+jcmcu.o : jcmcu.c jinclude.h jconfig.h jpegdata.h 
+jcpipe.o : jcpipe.c jinclude.h jconfig.h jpegdata.h 
+jcsample.o : jcsample.c jinclude.h jconfig.h jpegdata.h 
+jdarith.o : jdarith.c jinclude.h jconfig.h jpegdata.h 
+jdcolor.o : jdcolor.c jinclude.h jconfig.h jpegdata.h 
+jdhuff.o : jdhuff.c jinclude.h jconfig.h jpegdata.h 
+jdmain.o : jdmain.c jinclude.h jconfig.h jpegdata.h egetopt.c
+jdmaster.o : jdmaster.c jinclude.h jconfig.h jpegdata.h 
+jdmcu.o : jdmcu.c jinclude.h jconfig.h jpegdata.h 
+jdpipe.o : jdpipe.c jinclude.h jconfig.h jpegdata.h 
+jdsample.o : jdsample.c jinclude.h jconfig.h jpegdata.h 
+jerror.o : jerror.c jinclude.h jconfig.h jpegdata.h 
+jfwddct.o : jfwddct.c jinclude.h jconfig.h jpegdata.h 
+jquant1.o : jquant1.c jinclude.h jconfig.h jpegdata.h 
+jquant2.o : jquant2.c jinclude.h jconfig.h jpegdata.h 
+jrdjfif.o : jrdjfif.c jinclude.h jconfig.h jpegdata.h 
+jrdgif.o : jrdgif.c jinclude.h jconfig.h jpegdata.h 
+jrdppm.o : jrdppm.c jinclude.h jconfig.h jpegdata.h 
+jrevdct.o : jrevdct.c jinclude.h jconfig.h jpegdata.h 
+jutils.o : jutils.c jinclude.h jconfig.h jpegdata.h 
+jvirtmem.o : jvirtmem.c jinclude.h jconfig.h jpegdata.h 
+jwrjfif.o : jwrjfif.c jinclude.h jconfig.h jpegdata.h 
+jwrgif.o : jwrgif.c jinclude.h jconfig.h jpegdata.h 
+jwrppm.o : jwrppm.c jinclude.h jconfig.h jpegdata.h 
diff --git a/makljpeg.cf b/makljpeg.cf
new file mode 100644
index 0000000..3325bf4
--- /dev/null
+++ b/makljpeg.cf
@@ -0,0 +1,5 @@
+jbsmooth.mix,jcarith.mix,jccolor.mix,jcdeflts.mix,jcexpand.mix,jchuff.mix
+jcmaster.mix,jcmcu.mix,jcpipe.mix,jcsample.mix,jdarith.mix,jdcolor.mix
+jdhuff.mix,jdmaster.mix,jdmcu.mix,jdpipe.mix,jdsample.mix,jerror.mix
+jfwddct.mix,jquant1.mix,jquant2.mix,jrdgif.mix,jrdjfif.mix,jrdppm.mix
+jrevdct.mix,jutils.mix,jvirtmem.mix,jwrgif.mix,jwrjfif.mix,jwrppm.mix
diff --git a/testimg.jpg b/testimg.jpg
new file mode 100644
index 0000000..b6b68bc
--- /dev/null
+++ b/testimg.jpg
Binary files differ
diff --git a/testimg.ppm b/testimg.ppm
new file mode 100644
index 0000000..c7dab37
--- /dev/null
+++ b/testimg.ppm
Binary files differ
diff --git a/testorig.jpg b/testorig.jpg
new file mode 100644
index 0000000..1a628fc
--- /dev/null
+++ b/testorig.jpg
Binary files differ