Huffman coder and decoder compile cleanly now. Need to be used +tested however.

4 files changed, 412 insertions, 1 deletions

diff --git a/src/c_huffman.c b/src/c_huffman.c
new file mode 100644
index 0000000..acfcc92
--- /dev/null
+++ b/src/c_huffman.c
@@ -0,0 +1,207 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "config.h"
+#include "morecfg.h"
+
+#include "jpeglib.h"
+#include "jpegint.h"
+
+#include "c_huffman.h"
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+typedef struct {
+  INT32 put_buffer;		/* current bit-accumulation buffer */
+  int put_bits;			/* # of bits now in it */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* Working state while writing an MCU.
+ * This struct contains all the fields that are needed by subroutines.
+ */
+
+typedef struct {
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+  savable_state cur;		/* Current bit buffer & DC state */
+  j_compress_ptr cinfo;		/* dump_buffer needs access to this */
+} working_state;
+
+
+/* Outputting bytes to the file */
+
+/* Emit a byte, taking 'action' if must suspend. */
+#define emit_byte(state,val,action)  \
+	{ *(state)->next_output_byte++ = (JOCTET) (val);  \
+	  if (--(state)->free_in_buffer == 0)  \
+	    if (! dump_buffer(state))  \
+	      { action; } }
+
+
+/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
+static boolean dump_buffer(working_state * state) {
+	struct jpeg_destination_mgr * dest = state->cinfo->dest;
+
+	if (! (*dest->empty_output_buffer) (state->cinfo)) {
+		return FALSE;
+	}
+	/* After a successful buffer dump, must reset buffer pointers */
+	state->next_output_byte = dest->next_output_byte;
+	state->free_in_buffer = dest->free_in_buffer;
+	return TRUE;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+/* Emit some bits; return TRUE if successful, FALSE if must suspend */
+inline static boolean emit_bits(working_state * state, unsigned int code, int size) {
+	/* This routine is heavily used, so it's worth coding tightly. */
+	register INT32 put_buffer = (INT32) code;
+	register int put_bits = state->cur.put_bits;
+
+	/* if size is 0, caller used an invalid Huffman table entry */
+	if (size == 0) {
+		perror("Missing Huffman code table entry");
+		exit(0);
+		/* ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE); */
+	}
+
+	put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+  
+	put_bits += size;		/* new number of bits in buffer */
+  
+	put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+	put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
+  
+	while (put_bits >= 8) {
+		int c = (int) ((put_buffer >> 16) & 0xFF);
+    		emit_byte(state, c, return FALSE);
+		if (c == 0xFF) {		/* need to stuff a zero byte? */
+			emit_byte(state, 0, return FALSE);
+		}
+		put_buffer <<= 8;
+		put_bits -= 8;
+	}
+
+	state->cur.put_buffer = put_buffer; /* update state variables */
+	state->cur.put_bits = put_bits;
+
+	return TRUE;
+}
+
+
+int encode_one_block(working_state *state, JCOEFPTR block, int last_dc_val, c_derived_tbl *dctbl, c_derived_tbl *actbl) {
+	register int temp, temp2;
+	register int nbits;
+	register int k, r, i;
+
+	/* Encode the DC coefficient difference per section F.1.2.1 */
+
+	temp = temp2 = block[0] - last_dc_val;
+
+		if (temp < 0) {
+		temp = -temp;		/* temp is abs value of input */
+		/* For a negative input, want temp2 = bitwise complement of abs(input) */
+		/* This code assumes we are on a two's complement machine */
+		temp2--;
+	}
+  
+	/* Find the number of bits needed for the magnitude of the coefficient */
+	nbits = 0;
+	while (temp) {
+		nbits++;
+		temp >>= 1;
+	}
+	/* Check for out-of-range coefficient values.
+	 * Since we're encoding a difference, the range limit is twice as much.
+	 */
+	if (nbits > MAX_COEF_BITS+1) {
+		perror("DCT coefficient out of range");
+		exit(0);
+		/* ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); */
+	}
+	
+	/* Emit the Huffman-coded symbol for the number of bits */
+	if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits])) {
+		return FALSE;
+	}
+
+	/* Emit that number of bits of the value, if positive, */
+	/* or the complement of its magnitude, if negative. */
+	if (nbits) {			/* emit_bits rejects calls with size 0 */
+		if (! emit_bits(state, (unsigned int) temp2, nbits)) {
+			return FALSE;
+		}
+	}
+
+	/* Encode the AC coefficients per section F.1.2.2 */
+  
+	r = 0;			/* r = run length of zeros */
+  
+	for (k = 1; k < DCTSIZE2; k++) {
+		if ((temp = block[jpeg_natural_order[k]]) == 0) {
+			r++;
+		} else {
+			/* if run length > 15, must emit special run-length-16 codes (0xF0) */
+			while (r > 15) {
+				if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0])) {
+					return FALSE;
+				}
+				r -= 16;
+			}
+			
+			temp2 = temp;
+			if (temp < 0) {
+				temp = -temp;		/* temp is abs value of input */
+				/* This code assumes we are on a two's complement machine */
+				temp2--;
+			}
+      
+			/* Find the number of bits needed for the magnitude of the coefficient */
+			nbits = 1;		/* there must be at least one 1 bit */
+			while ((temp >>= 1)) {
+				nbits++;
+			}
+			/* Check for out-of-range coefficient values */
+			if (nbits > MAX_COEF_BITS) {
+				perror("DCT coefficient out of range");
+				exit(0);
+				/* ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); */
+			}
+      
+			/* Emit Huffman symbol for run length / number of bits */
+			i = (r << 4) + nbits;
+			if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i])) {
+				return FALSE;
+			}
+
+			/* Emit that number of bits of the value, if positive, */
+			/* or the complement of its magnitude, if negative. */
+			if (! emit_bits(state, (unsigned int) temp2, nbits)) {
+				return FALSE;
+			}
+      
+			r = 0;
+		}
+	}
+
+	/* If the last coef(s) were zero, emit an end-of-block code */
+	if (r > 0) {
+		if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0])) {
+		      return FALSE;
+		}
+	}
+	return TRUE;
+}
diff --git a/src/d_huffman.c b/src/d_huffman.c
new file mode 100644
index 0000000..7431f98
--- /dev/null
+++ b/src/d_huffman.c
@@ -0,0 +1,172 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "config.h"
+#include "morecfg.h"
+
+#include "jpeglib.h"
+#include "jpegint.h"
+
+#include "d_huffman.h"
+
+
+/*
+ * Out-of-line code for bit fetching (shared with jdphuff.c).
+ * See jdhuff.h for info about usage.
+ * Note: current values of get_buffer and bits_left are passed as parameters,
+ * but are returned in the corresponding fields of the state struct.
+ *
+ * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
+ * of get_buffer to be used.  (On machines with wider words, an even larger
+ * buffer could be used.)  However, on some machines 32-bit shifts are
+ * quite slow and take time proportional to the number of places shifted.
+ * (This is true with most PC compilers, for instance.)  In this case it may
+ * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
+ * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
+ */
+
+#ifdef SLOW_SHIFT_32
+#define MIN_GET_BITS  15	/* minimum allowable value */
+#else
+#define MIN_GET_BITS  (BIT_BUF_SIZE-7)
+#endif
+
+/* Load up the bit buffer to a depth of at least nbits */
+boolean jpeg_fill_bit_buffer(bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, int nbits) {
+	/* Copy heavily used state fields into locals (hopefully registers) */
+	register const JOCTET * next_input_byte = state->next_input_byte;
+	register size_t bytes_in_buffer = state->bytes_in_buffer;
+	j_decompress_ptr cinfo = state->cinfo;
+
+	/* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+	/* (It is assumed that no request will be for more than that many bits.) */
+	/* We fail to do so only if we hit a marker or are forced to suspend. */
+
+	if (cinfo->unread_marker == 0) {	/* cannot advance past a marker */
+		while (bits_left < MIN_GET_BITS) {
+			register int c;
+
+			/* Attempt to read a byte */
+			if (bytes_in_buffer == 0) {
+				if (! (*cinfo->src->fill_input_buffer) (cinfo)) {
+					return FALSE;
+				}
+				next_input_byte = cinfo->src->next_input_byte;
+				bytes_in_buffer = cinfo->src->bytes_in_buffer;
+			}
+			bytes_in_buffer--;
+			c = GETJOCTET(*next_input_byte++);
+
+			/* If it's 0xFF, check and discard stuffed zero byte */
+			if (c == 0xFF) {
+				/* Loop here to discard any padding FF's on terminating marker,
+				 * so that we can save a valid unread_marker value.  NOTE: we will
+				 * accept multiple FF's followed by a 0 as meaning a single FF data
+				 * byte.  This data pattern is not valid according to the standard.
+				 */
+				do {
+					if (bytes_in_buffer == 0) {
+						if (! (*cinfo->src->fill_input_buffer) (cinfo)) {
+							return FALSE;
+						}
+						next_input_byte = cinfo->src->next_input_byte;
+						bytes_in_buffer = cinfo->src->bytes_in_buffer;
+					}
+					bytes_in_buffer--;
+					c = GETJOCTET(*next_input_byte++);
+				} while (c == 0xFF);
+
+				if (c == 0) {
+				/* Found FF/00, which represents an FF data byte */
+					c = 0xFF;
+				} else {
+					/* Oops, it's actually a marker indicating end of compressed data.
+					 * Save the marker code for later use.
+					 * Fine point: it might appear that we should save the marker into
+					 * bitread working state, not straight into permanent state.  But
+		 			 * once we have hit a marker, we cannot need to suspend within the
+					 * current MCU, because we will read no more bytes from the data
+					 * source.  So it is OK to update permanent state right away.
+					 */
+					cinfo->unread_marker = c;
+					/* See if we need to insert some fake zero bits. */
+					goto no_more_bytes;
+				}
+			}
+
+			/* OK, load c into get_buffer */
+			get_buffer = (get_buffer << 8) | c;
+			bits_left += 8;
+		} /* end while */
+	} else {
+		no_more_bytes:
+		/* We get here if we've read the marker that terminates the compressed
+		 * data segment.  There should be enough bits in the buffer register
+		 * to satisfy the request; if so, no problem.
+		 */
+		if (nbits > bits_left) {
+			/* Uh-oh.  Report corrupted data to user and stuff zeroes into
+			 * the data stream, so that we can produce some kind of image.
+			 * We use a nonvolatile flag to ensure that only one warning message
+			 * appears per data segment.
+			 */
+			if (!cinfo->entropy->insufficient_data) {
+				perror("Corrupt JPEG data: premature end of data segment");
+				/* WARNMS(cinfo, JWRN_HIT_MARKER); */
+				cinfo->entropy->insufficient_data = TRUE;
+			}
+			/* Fill the buffer with zero bits */
+			get_buffer <<= MIN_GET_BITS - bits_left;
+			bits_left = MIN_GET_BITS;
+		}
+	}
+
+	/* Unload the local registers */
+	state->next_input_byte = next_input_byte;
+	state->bytes_in_buffer = bytes_in_buffer;
+	state->get_buffer = get_buffer;
+	state->bits_left = bits_left;
+
+	return TRUE;
+}
+
+
+/*
+ * Out-of-line code for Huffman code decoding.
+ * See jdhuff.h for info about usage.
+ */
+
+int jpeg_huff_decode(bitread_working_state *state, register bit_buf_type get_buffer, register int bits_left, d_derived_tbl *htbl, int min_bits) {
+	register int l = min_bits;
+	register INT32 code;
+
+	/* HUFF_DECODE has determined that the code is at least min_bits */
+	/* bits long, so fetch that many bits in one swoop. */
+
+	CHECK_BIT_BUFFER(*state, l, return -1);
+	code = GET_BITS(l);
+
+	/* Collect the rest of the Huffman code one bit at a time. */
+	/* This is per Figure F.16 in the JPEG spec. */
+
+	while (code > htbl->maxcode[l]) {
+		code <<= 1;
+		CHECK_BIT_BUFFER(*state, 1, return -1);
+		code |= GET_BITS(1);
+		l++;
+	}
+
+	/* Unload the local registers */
+	state->get_buffer = get_buffer;
+	state->bits_left = bits_left;
+
+	/* With garbage input we may reach the sentinel value l = 17. */
+
+	if (l > 16) {
+		perror("Corrupt JPEG data: bad Huffman code");
+/*		WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE); */
+		return 0;			/* fake a zero as the safest result */
+	}
+
+	return htbl->pub->huffval[ (int)(code + htbl->valoffset[l]) ];
+}
diff --git a/src/e_huffman.c b/src/e_huffman.c
deleted file mode 100644
index ea97f4a..0000000
--- a/src/e_huffman.c
+++ /dev/null
@@ -1 +0,0 @@
-#include "huffman.h"
diff --git a/src/utils.c b/src/utils.c
new file mode 100644
index 0000000..0ffa074
--- /dev/null
+++ b/src/utils.c
@@ -0,0 +1,33 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "config.h"
+#include "morecfg.h"
+
+#include "jpeglib.h"
+/*
+ * jpeg_natural_order[i] is the natural-order position of the i'th element
+ * of zigzag order.
+ *
+ * When reading corrupted data, the Huffman decoders could attempt
+ * to reference an entry beyond the end of this array (if the decoded
+ * zero run length reaches past the end of the block).  To prevent
+ * wild stores without adding an inner-loop test, we put some extra
+ * "63"s after the real entries.  This will cause the extra coefficient
+ * to be stored in location 63 of the block, not somewhere random.
+ * The worst case would be a run-length of 15, which means we need 16
+ * fake entries.
+ */
+
+const int jpeg_natural_order[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,
+ 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+ 63, 63, 63, 63, 63, 63, 63, 63
+};