rdrle.c

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