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