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