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