workbench/libs/jpeg/rdrle.c

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