Remove damned ancient DOS line endings from Irrlicht. Hopefully I did not go overboard.

1 files changed, 387 insertions, 387 deletions

diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c
index df871e0..542bc37 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c
+++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/rdrle.c
@@ -1,387 +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 */

+/*
+ * 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 */