compiler/libjpeg/test/rdrle.c

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