1 files changed, 387 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c
new file mode 100644
index 0000000..df871e0
--- /dev/null
+++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c
@@ -0,0 +1,387 @@
+/*
+ * rdrle.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to read input images in Utah RLE format.
+ * The Utah Raster Toolkit library is required (version 3.1 or later).
+ *
+ * These routines may need modification for non-Unix environments or
+ * specialized applications.  As they stand, they assume input from
+ * an ordinary stdio stream.  They further assume that reading begins
+ * at the start of the file; start_input may need work if the
+ * user interface has already read some data (e.g., to determine that
+ * the file is indeed RLE format).
+ *
+ * Based on code contributed by Mike Lijewski,
+ * with updates from Robert Hutchinson.
+ */
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#ifdef RLE_SUPPORTED
+/* rle.h is provided by the Utah Raster Toolkit. */
+#include <rle.h>
+/*
+ * We assume that JSAMPLE has the same representation as rle_pixel,
+ * to wit, "unsigned char".  Hence we can't cope with 12- or 16-bit samples.
+ */
+#if BITS_IN_JSAMPLE != 8
+  Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
+#endif
+/*
+ * We support the following types of RLE files:
+ *   
+ *   GRAYSCALE   - 8 bits, no colormap
+ *   MAPPEDGRAY  - 8 bits, 1 channel colomap
+ *   PSEUDOCOLOR - 8 bits, 3 channel colormap
+ *   TRUECOLOR   - 24 bits, 3 channel colormap
+ *   DIRECTCOLOR - 24 bits, no colormap
+ *
+ * For now, we ignore any alpha channel in the image.
+ */
+typedef enum
+  { GRAYSCALE, MAPPEDGRAY, PSEUDOCOLOR, TRUECOLOR, DIRECTCOLOR } rle_kind;
+/*
+ * Since RLE stores scanlines bottom-to-top, we have to invert the image
+ * to conform to JPEG's top-to-bottom order.  To do this, we read the
+ * incoming image into a virtual array on the first get_pixel_rows call,
+ * then fetch the required row from the virtual array on subsequent calls.
+ */
+typedef struct _rle_source_struct * rle_source_ptr;
+typedef struct _rle_source_struct {
+  struct cjpeg_source_struct pub; /* public fields */
+  rle_kind visual;              /* actual type of input file */
+  jvirt_sarray_ptr image;       /* virtual array to hold the image */
+  JDIMENSION row;               /* current row # in the virtual array */
+  rle_hdr header;               /* Input file information */
+  rle_pixel** rle_row;          /* holds a row returned by rle_getrow() */
+} rle_source_struct;
+/*
+ * Read the file header; return image size and component count.
+ */
+METHODDEF(void)
+start_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  rle_source_ptr source = (rle_source_ptr) sinfo;
+  JDIMENSION width, height;
+#ifdef PROGRESS_REPORT
+  cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
+#endif
+  /* Use RLE library routine to get the header info */
+  source->header = *rle_hdr_init(NULL);
+  source->header.rle_file = source->pub.input_file;
+  switch (rle_get_setup(&(source->header))) {
+  case RLE_SUCCESS:
+    /* A-OK */
+    break;
+  case RLE_NOT_RLE:
+    ERREXIT(cinfo, JERR_RLE_NOT);
+    break;
+  case RLE_NO_SPACE:
+    ERREXIT(cinfo, JERR_RLE_MEM);
+    break;
+  case RLE_EMPTY:
+    ERREXIT(cinfo, JERR_RLE_EMPTY);
+    break;
+  case RLE_EOF:
+    ERREXIT(cinfo, JERR_RLE_EOF);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_RLE_BADERROR);
+    break;
+  }
+  /* Figure out what we have, set private vars and return values accordingly */
+  
+  width  = source->header.xmax - source->header.xmin + 1;
+  height = source->header.ymax - source->header.ymin + 1;
+  source->header.xmin = 0;              /* realign horizontally */
+  source->header.xmax = width-1;
+  cinfo->image_width      = width;
+  cinfo->image_height     = height;
+  cinfo->data_precision   = 8;  /* we can only handle 8 bit data */
+  if (source->header.ncolors == 1 && source->header.ncmap == 0) {
+    source->visual     = GRAYSCALE;
+    TRACEMS2(cinfo, 1, JTRC_RLE_GRAY, width, height);
+  } else if (source->header.ncolors == 1 && source->header.ncmap == 1) {
+    source->visual     = MAPPEDGRAY;
+    TRACEMS3(cinfo, 1, JTRC_RLE_MAPGRAY, width, height,
+             1 << source->header.cmaplen);
+  } else if (source->header.ncolors == 1 && source->header.ncmap == 3) {
+    source->visual     = PSEUDOCOLOR;
+    TRACEMS3(cinfo, 1, JTRC_RLE_MAPPED, width, height,
+             1 << source->header.cmaplen);
+  } else if (source->header.ncolors == 3 && source->header.ncmap == 3) {
+    source->visual     = TRUECOLOR;
+    TRACEMS3(cinfo, 1, JTRC_RLE_FULLMAP, width, height,
+             1 << source->header.cmaplen);
+  } else if (source->header.ncolors == 3 && source->header.ncmap == 0) {
+    source->visual     = DIRECTCOLOR;
+    TRACEMS2(cinfo, 1, JTRC_RLE, width, height);
+  } else
+    ERREXIT(cinfo, JERR_RLE_UNSUPPORTED);
+  
+  if (source->visual == GRAYSCALE || source->visual == MAPPEDGRAY) {
+    cinfo->in_color_space   = JCS_GRAYSCALE;
+    cinfo->input_components = 1;
+  } else {
+    cinfo->in_color_space   = JCS_RGB;
+    cinfo->input_components = 3;
+  }
+  /*
+   * A place to hold each scanline while it's converted.
+   * (GRAYSCALE scanlines don't need converting)
+   */
+  if (source->visual != GRAYSCALE) {
+    source->rle_row = (rle_pixel**) (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       (JDIMENSION) width, (JDIMENSION) cinfo->input_components);
+  }
+  /* request a virtual array to hold the image */
+  source->image = (*cinfo->mem->request_virt_sarray)
+    ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+     (JDIMENSION) (width * source->header.ncolors),
+     (JDIMENSION) height, (JDIMENSION) 1);
+#ifdef PROGRESS_REPORT
+  if (progress != NULL) {
+    /* count file input as separate pass */
+    progress->total_extra_passes++;
+  }
+#endif
+  source->pub.buffer_height = 1;
+}
+/*
+ * Read one row of pixels.
+ * Called only after load_image has read the image into the virtual array.
+ * Used for GRAYSCALE, MAPPEDGRAY, TRUECOLOR, and DIRECTCOLOR images.
+ */
+METHODDEF(JDIMENSION)
+get_rle_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  rle_source_ptr source = (rle_source_ptr) sinfo;
+  source->row--;
+  source->pub.buffer = (*cinfo->mem->access_virt_sarray)
+    ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE);
+  return 1;
+}
+/*
+ * Read one row of pixels.
+ * Called only after load_image has read the image into the virtual array.
+ * Used for PSEUDOCOLOR images.
+ */
+METHODDEF(JDIMENSION)
+get_pseudocolor_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  rle_source_ptr source = (rle_source_ptr) sinfo;
+  JSAMPROW src_row, dest_row;
+  JDIMENSION col;
+  rle_map *colormap;
+  int val;
+  colormap = source->header.cmap;
+  dest_row = source->pub.buffer[0];
+  source->row--;
+  src_row = * (*cinfo->mem->access_virt_sarray)
+    ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE);
+  for (col = cinfo->image_width; col > 0; col--) {
+    val = GETJSAMPLE(*src_row++);
+    *dest_row++ = (JSAMPLE) (colormap[val      ] >> 8);
+    *dest_row++ = (JSAMPLE) (colormap[val + 256] >> 8);
+    *dest_row++ = (JSAMPLE) (colormap[val + 512] >> 8);
+  }
+  return 1;
+}
+/*
+ * Load the image into a virtual array.  We have to do this because RLE
+ * files start at the lower left while the JPEG standard has them starting
+ * in the upper left.  This is called the first time we want to get a row
+ * of input.  What we do is load the RLE data into the array and then call
+ * the appropriate routine to read one row from the array.  Before returning,
+ * we set source->pub.get_pixel_rows so that subsequent calls go straight to
+ * the appropriate row-reading routine.
+ */
+METHODDEF(JDIMENSION)
+load_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  rle_source_ptr source = (rle_source_ptr) sinfo;
+  JDIMENSION row, col;
+  JSAMPROW  scanline, red_ptr, green_ptr, blue_ptr;
+  rle_pixel **rle_row;
+  rle_map *colormap;
+  char channel;
+#ifdef PROGRESS_REPORT
+  cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
+#endif
+  colormap = source->header.cmap;
+  rle_row = source->rle_row;
+  /* Read the RLE data into our virtual array.
+   * We assume here that (a) rle_pixel is represented the same as JSAMPLE,
+   * and (b) we are not on a machine where FAR pointers differ from regular.
+   */
+  RLE_CLR_BIT(source->header, RLE_ALPHA); /* don't read the alpha channel */
+#ifdef PROGRESS_REPORT
+  if (progress != NULL) {
+    progress->pub.pass_limit = cinfo->image_height;
+    progress->pub.pass_counter = 0;
+    (*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
+  }
+#endif
+  switch (source->visual) {
+  case GRAYSCALE:
+  case PSEUDOCOLOR:
+    for (row = 0; row < cinfo->image_height; row++) {
+      rle_row = (rle_pixel **) (*cinfo->mem->access_virt_sarray)
+         ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE);
+      rle_getrow(&source->header, rle_row);
+#ifdef PROGRESS_REPORT
+      if (progress != NULL) {
+        progress->pub.pass_counter++;
+        (*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
+      }
+#endif
+    }
+    break;
+  case MAPPEDGRAY:
+  case TRUECOLOR:
+    for (row = 0; row < cinfo->image_height; row++) {
+      scanline = * (*cinfo->mem->access_virt_sarray)
+        ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE);
+      rle_row = source->rle_row;
+      rle_getrow(&source->header, rle_row);
+      for (col = 0; col < cinfo->image_width; col++) {
+        for (channel = 0; channel < source->header.ncolors; channel++) {
+          *scanline++ = (JSAMPLE)
+            (colormap[GETJSAMPLE(rle_row[channel][col]) + 256 * channel] >> 8);
+        }
+      }
+#ifdef PROGRESS_REPORT
+      if (progress != NULL) {
+        progress->pub.pass_counter++;
+        (*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
+      }
+#endif
+    }
+    break;
+  case DIRECTCOLOR:
+    for (row = 0; row < cinfo->image_height; row++) {
+      scanline = * (*cinfo->mem->access_virt_sarray)
+        ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE);
+      rle_getrow(&source->header, rle_row);
+      red_ptr   = rle_row[0];
+      green_ptr = rle_row[1];
+      blue_ptr  = rle_row[2];
+      for (col = cinfo->image_width; col > 0; col--) {
+        *scanline++ = *red_ptr++;
+        *scanline++ = *green_ptr++;
+        *scanline++ = *blue_ptr++;
+      }
+#ifdef PROGRESS_REPORT
+      if (progress != NULL) {
+        progress->pub.pass_counter++;
+        (*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
+      }
+#endif
+    }
+  }
+#ifdef PROGRESS_REPORT
+  if (progress != NULL)
+    progress->completed_extra_passes++;
+#endif
+  /* Set up to call proper row-extraction routine in future */
+  if (source->visual == PSEUDOCOLOR) {
+    source->pub.buffer = source->rle_row;
+    source->pub.get_pixel_rows = get_pseudocolor_row;
+  } else {
+    source->pub.get_pixel_rows = get_rle_row;
+  }
+  source->row = cinfo->image_height;
+  /* And fetch the topmost (bottommost) row */
+  return (*source->pub.get_pixel_rows) (cinfo, sinfo);   
+}
+/*
+ * Finish up at the end of the file.
+ */
+METHODDEF(void)
+finish_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
+{
+  /* no work */
+}
+/*
+ * The module selection routine for RLE format input.
+ */
+GLOBAL(cjpeg_source_ptr)
+jinit_read_rle (j_compress_ptr cinfo)
+{
+  rle_source_ptr source;
+  /* Create module interface object */
+  source = (rle_source_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                  SIZEOF(rle_source_struct));
+  /* Fill in method ptrs */
+  source->pub.start_input = start_input_rle;
+  source->pub.finish_input = finish_input_rle;
+  source->pub.get_pixel_rows = load_image;
+  return (cjpeg_source_ptr) source;
+}
+#endif /* RLE_SUPPORTED */

diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c new file mode 100644 index 0000000..df871e0 --- /dev/null +++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c
@@ -0,0 +1,387 @@
	1	/*
	2	* rdrle.c
	3	*
	4	* Copyright (C) 1991-1996, Thomas G. Lane.
	5	* This file is part of the Independent JPEG Group's software.
	6	* For conditions of distribution and use, see the accompanying README file.
	7	*
	8	* This file contains routines to read input images in Utah RLE format.
	9	* The Utah Raster Toolkit library is required (version 3.1 or later).
	10	*
	11	* These routines may need modification for non-Unix environments or
	12	* specialized applications. As they stand, they assume input from
	13	* an ordinary stdio stream. They further assume that reading begins
	14	* at the start of the file; start_input may need work if the
	15	* user interface has already read some data (e.g., to determine that
	16	* the file is indeed RLE format).
	17	*
	18	* Based on code contributed by Mike Lijewski,
	19	* with updates from Robert Hutchinson.
	20	*/
	21
	22	#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
	23
	24	#ifdef RLE_SUPPORTED
	25
	26	/* rle.h is provided by the Utah Raster Toolkit. */
	27
	28	#include <rle.h>
	29
	30	/*
	31	* We assume that JSAMPLE has the same representation as rle_pixel,
	32	* to wit, "unsigned char". Hence we can't cope with 12- or 16-bit samples.
	33	*/
	34
	35	#if BITS_IN_JSAMPLE != 8
	36	Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
	37	#endif
	38
	39	/*
	40	* We support the following types of RLE files:
	41	*
	42	* GRAYSCALE - 8 bits, no colormap
	43	* MAPPEDGRAY - 8 bits, 1 channel colomap
	44	* PSEUDOCOLOR - 8 bits, 3 channel colormap
	45	* TRUECOLOR - 24 bits, 3 channel colormap
	46	* DIRECTCOLOR - 24 bits, no colormap
	47	*
	48	* For now, we ignore any alpha channel in the image.
	49	*/
	50
	51	typedef enum
	52	{ GRAYSCALE, MAPPEDGRAY, PSEUDOCOLOR, TRUECOLOR, DIRECTCOLOR } rle_kind;
	53
	54
	55	/*
	56	* Since RLE stores scanlines bottom-to-top, we have to invert the image
	57	* to conform to JPEG's top-to-bottom order. To do this, we read the
	58	* incoming image into a virtual array on the first get_pixel_rows call,
	59	* then fetch the required row from the virtual array on subsequent calls.
	60	*/
	61
	62	typedef struct _rle_source_struct * rle_source_ptr;
	63
	64	typedef struct _rle_source_struct {
	65	struct cjpeg_source_struct pub; /* public fields */
	66
	67	rle_kind visual; /* actual type of input file */
	68	jvirt_sarray_ptr image; /* virtual array to hold the image */
	69	JDIMENSION row; /* current row # in the virtual array */
	70	rle_hdr header; /* Input file information */
	71	rle_pixel** rle_row; /* holds a row returned by rle_getrow() */
	72
	73	} rle_source_struct;
	74
	75
	76	/*
	77	* Read the file header; return image size and component count.
	78	*/
	79
	80	METHODDEF(void)
	81	start_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
	82	{
	83	rle_source_ptr source = (rle_source_ptr) sinfo;
	84	JDIMENSION width, height;
	85	#ifdef PROGRESS_REPORT
	86	cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
	87	#endif
	88
	89	/* Use RLE library routine to get the header info */
	90	source->header = *rle_hdr_init(NULL);
	91	source->header.rle_file = source->pub.input_file;
	92	switch (rle_get_setup(&(source->header))) {
	93	case RLE_SUCCESS:
	94	/* A-OK */
	95	break;
	96	case RLE_NOT_RLE:
	97	ERREXIT(cinfo, JERR_RLE_NOT);
	98	break;
	99	case RLE_NO_SPACE:
	100	ERREXIT(cinfo, JERR_RLE_MEM);
	101	break;
	102	case RLE_EMPTY:
	103	ERREXIT(cinfo, JERR_RLE_EMPTY);
	104	break;
	105	case RLE_EOF:
	106	ERREXIT(cinfo, JERR_RLE_EOF);
	107	break;
	108	default:
	109	ERREXIT(cinfo, JERR_RLE_BADERROR);
	110	break;
	111	}
	112
	113	/* Figure out what we have, set private vars and return values accordingly */
	114
	115	width = source->header.xmax - source->header.xmin + 1;
	116	height = source->header.ymax - source->header.ymin + 1;
	117	source->header.xmin = 0; /* realign horizontally */
	118	source->header.xmax = width-1;
	119
	120	cinfo->image_width = width;
	121	cinfo->image_height = height;
	122	cinfo->data_precision = 8; /* we can only handle 8 bit data */
	123
	124	if (source->header.ncolors == 1 && source->header.ncmap == 0) {
	125	source->visual = GRAYSCALE;
	126	TRACEMS2(cinfo, 1, JTRC_RLE_GRAY, width, height);
	127	} else if (source->header.ncolors == 1 && source->header.ncmap == 1) {
	128	source->visual = MAPPEDGRAY;
	129	TRACEMS3(cinfo, 1, JTRC_RLE_MAPGRAY, width, height,
	130	1 << source->header.cmaplen);
	131	} else if (source->header.ncolors == 1 && source->header.ncmap == 3) {
	132	source->visual = PSEUDOCOLOR;
	133	TRACEMS3(cinfo, 1, JTRC_RLE_MAPPED, width, height,
	134	1 << source->header.cmaplen);
	135	} else if (source->header.ncolors == 3 && source->header.ncmap == 3) {
	136	source->visual = TRUECOLOR;
	137	TRACEMS3(cinfo, 1, JTRC_RLE_FULLMAP, width, height,
	138	1 << source->header.cmaplen);
	139	} else if (source->header.ncolors == 3 && source->header.ncmap == 0) {
	140	source->visual = DIRECTCOLOR;
	141	TRACEMS2(cinfo, 1, JTRC_RLE, width, height);
	142	} else
	143	ERREXIT(cinfo, JERR_RLE_UNSUPPORTED);
	144
	145	if (source->visual == GRAYSCALE \|\| source->visual == MAPPEDGRAY) {
	146	cinfo->in_color_space = JCS_GRAYSCALE;
	147	cinfo->input_components = 1;
	148	} else {
	149	cinfo->in_color_space = JCS_RGB;
	150	cinfo->input_components = 3;
	151	}
	152
	153	/*
	154	* A place to hold each scanline while it's converted.
	155	* (GRAYSCALE scanlines don't need converting)
	156	*/
	157	if (source->visual != GRAYSCALE) {
	158	source->rle_row = (rle_pixel*) (cinfo->mem->alloc_sarray)
	159	((j_common_ptr) cinfo, JPOOL_IMAGE,
	160	(JDIMENSION) width, (JDIMENSION) cinfo->input_components);
	161	}
	162
	163	/* request a virtual array to hold the image */
	164	source->image = (*cinfo->mem->request_virt_sarray)
	165	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
	166	(JDIMENSION) (width * source->header.ncolors),
	167	(JDIMENSION) height, (JDIMENSION) 1);
	168
	169	#ifdef PROGRESS_REPORT
	170	if (progress != NULL) {
	171	/* count file input as separate pass */
	172	progress->total_extra_passes++;
	173	}
	174	#endif
	175
	176	source->pub.buffer_height = 1;
	177	}
	178
	179
	180	/*
	181	* Read one row of pixels.
	182	* Called only after load_image has read the image into the virtual array.
	183	* Used for GRAYSCALE, MAPPEDGRAY, TRUECOLOR, and DIRECTCOLOR images.
	184	*/
	185
	186	METHODDEF(JDIMENSION)
	187	get_rle_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
	188	{
	189	rle_source_ptr source = (rle_source_ptr) sinfo;
	190
	191	source->row--;
	192	source->pub.buffer = (*cinfo->mem->access_virt_sarray)
	193	((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE);
	194
	195	return 1;
	196	}
	197
	198	/*
	199	* Read one row of pixels.
	200	* Called only after load_image has read the image into the virtual array.
	201	* Used for PSEUDOCOLOR images.
	202	*/
	203
	204	METHODDEF(JDIMENSION)
	205	get_pseudocolor_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
	206	{
	207	rle_source_ptr source = (rle_source_ptr) sinfo;
	208	JSAMPROW src_row, dest_row;
	209	JDIMENSION col;
	210	rle_map *colormap;
	211	int val;
	212
	213	colormap = source->header.cmap;
	214	dest_row = source->pub.buffer[0];
	215	source->row--;
	216	src_row = * (*cinfo->mem->access_virt_sarray)
	217	((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE);
	218
	219	for (col = cinfo->image_width; col > 0; col--) {
	220	val = GETJSAMPLE(*src_row++);
	221	*dest_row++ = (JSAMPLE) (colormap[val ] >> 8);
	222	*dest_row++ = (JSAMPLE) (colormap[val + 256] >> 8);
	223	*dest_row++ = (JSAMPLE) (colormap[val + 512] >> 8);
	224	}
	225
	226	return 1;
	227	}
	228
	229
	230	/*
	231	* Load the image into a virtual array. We have to do this because RLE
	232	* files start at the lower left while the JPEG standard has them starting
	233	* in the upper left. This is called the first time we want to get a row
	234	* of input. What we do is load the RLE data into the array and then call
	235	* the appropriate routine to read one row from the array. Before returning,
	236	* we set source->pub.get_pixel_rows so that subsequent calls go straight to
	237	* the appropriate row-reading routine.
	238	*/
	239
	240	METHODDEF(JDIMENSION)
	241	load_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
	242	{
	243	rle_source_ptr source = (rle_source_ptr) sinfo;
	244	JDIMENSION row, col;
	245	JSAMPROW scanline, red_ptr, green_ptr, blue_ptr;
	246	rle_pixel **rle_row;
	247	rle_map *colormap;
	248	char channel;
	249	#ifdef PROGRESS_REPORT
	250	cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
	251	#endif
	252
	253	colormap = source->header.cmap;
	254	rle_row = source->rle_row;
	255
	256	/* Read the RLE data into our virtual array.
	257	* We assume here that (a) rle_pixel is represented the same as JSAMPLE,
	258	* and (b) we are not on a machine where FAR pointers differ from regular.
	259	*/
	260	RLE_CLR_BIT(source->header, RLE_ALPHA); /* don't read the alpha channel */
	261
	262	#ifdef PROGRESS_REPORT
	263	if (progress != NULL) {
	264	progress->pub.pass_limit = cinfo->image_height;
	265	progress->pub.pass_counter = 0;
	266	(*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
	267	}
	268	#endif
	269
	270	switch (source->visual) {
	271
	272	case GRAYSCALE:
	273	case PSEUDOCOLOR:
	274	for (row = 0; row < cinfo->image_height; row++) {
	275	rle_row = (rle_pixel *) (cinfo->mem->access_virt_sarray)
	276	((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE);
	277	rle_getrow(&source->header, rle_row);
	278	#ifdef PROGRESS_REPORT
	279	if (progress != NULL) {
	280	progress->pub.pass_counter++;
	281	(*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
	282	}
	283	#endif
	284	}
	285	break;
	286
	287	case MAPPEDGRAY:
	288	case TRUECOLOR:
	289	for (row = 0; row < cinfo->image_height; row++) {
	290	scanline = * (*cinfo->mem->access_virt_sarray)
	291	((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE);
	292	rle_row = source->rle_row;
	293	rle_getrow(&source->header, rle_row);
	294
	295	for (col = 0; col < cinfo->image_width; col++) {
	296	for (channel = 0; channel < source->header.ncolors; channel++) {
	297	*scanline++ = (JSAMPLE)
	298	(colormap[GETJSAMPLE(rle_row[channel][col]) + 256 * channel] >> 8);
	299	}
	300	}
	301
	302	#ifdef PROGRESS_REPORT
	303	if (progress != NULL) {
	304	progress->pub.pass_counter++;
	305	(*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
	306	}
	307	#endif
	308	}
	309	break;
	310
	311	case DIRECTCOLOR:
	312	for (row = 0; row < cinfo->image_height; row++) {
	313	scanline = * (*cinfo->mem->access_virt_sarray)
	314	((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE);
	315	rle_getrow(&source->header, rle_row);
	316
	317	red_ptr = rle_row[0];
	318	green_ptr = rle_row[1];
	319	blue_ptr = rle_row[2];
	320
	321	for (col = cinfo->image_width; col > 0; col--) {
	322	scanline++ = red_ptr++;
	323	scanline++ = green_ptr++;
	324	scanline++ = blue_ptr++;
	325	}
	326
	327	#ifdef PROGRESS_REPORT
	328	if (progress != NULL) {
	329	progress->pub.pass_counter++;
	330	(*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
	331	}
	332	#endif
	333	}
	334	}
	335
	336	#ifdef PROGRESS_REPORT
	337	if (progress != NULL)
	338	progress->completed_extra_passes++;
	339	#endif
	340
	341	/* Set up to call proper row-extraction routine in future */
	342	if (source->visual == PSEUDOCOLOR) {
	343	source->pub.buffer = source->rle_row;
	344	source->pub.get_pixel_rows = get_pseudocolor_row;
	345	} else {
	346	source->pub.get_pixel_rows = get_rle_row;
	347	}
	348	source->row = cinfo->image_height;
	349
	350	/* And fetch the topmost (bottommost) row */
	351	return (*source->pub.get_pixel_rows) (cinfo, sinfo);
	352	}
	353
	354
	355	/*
	356	* Finish up at the end of the file.
	357	*/
	358
	359	METHODDEF(void)
	360	finish_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
	361	{
	362	/* no work */
	363	}
	364
	365
	366	/*
	367	* The module selection routine for RLE format input.
	368	*/
	369
	370	GLOBAL(cjpeg_source_ptr)
	371	jinit_read_rle (j_compress_ptr cinfo)
	372	{
	373	rle_source_ptr source;
	374
	375	/* Create module interface object */
	376	source = (rle_source_ptr)
	377	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
	378	SIZEOF(rle_source_struct));
	379	/* Fill in method ptrs */
	380	source->pub.start_input = start_input_rle;
	381	source->pub.finish_input = finish_input_rle;
	382	source->pub.get_pixel_rows = load_image;
	383
	384	return (cjpeg_source_ptr) source;
	385	}
	386
	387	#endif /* RLE_SUPPORTED */