1 /* 2 * rdtarga.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 relevant 7 * 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 Targa format. 11 * 12 * These routines may need modification for non-Unix environments or 13 * specialized applications. As they stand, they assume input from 14 * an ordinary stdio stream. They further assume that reading begins 15 * at the start of the file; start_input may need work if the 16 * user interface has already read some data (e.g., to determine that 17 * the file is indeed Targa format). 18 * 19 * Based on code contributed by Lee Daniel Crocker. 20 */ 21 22 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ 23 24 #ifdef TARGA_SUPPORTED 25 26 27 /* Macros to deal with unsigned chars as efficiently as compiler allows */ 28 29 #ifdef HAVE_UNSIGNED_CHAR 30 typedef unsigned char U_CHAR; 31 #define UCH(x) ((int) (x)) 32 #else /* !HAVE_UNSIGNED_CHAR */ 33 #ifdef __CHAR_UNSIGNED__ 34 typedef char U_CHAR; 35 #define UCH(x) ((int) (x)) 36 #else 37 typedef char U_CHAR; 38 #define UCH(x) ((int) (x) & 0xFF) 39 #endif 40 #endif /* HAVE_UNSIGNED_CHAR */ 41 42 43 #define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len))) 44 45 46 /* Private version of data source object */ 47 48 typedef struct _tga_source_struct * tga_source_ptr; 49 50 typedef struct _tga_source_struct { 51 struct cjpeg_source_struct pub; /* public fields */ 52 53 j_compress_ptr cinfo; /* back link saves passing separate parm */ 54 55 JSAMPARRAY colormap; /* Targa colormap (converted to my format) */ 56 57 jvirt_sarray_ptr whole_image; /* Needed if funny input row order */ 58 JDIMENSION current_row; /* Current logical row number to read */ 59 60 /* Pointer to routine to extract next Targa pixel from input file */ 61 void (*read_pixel) (tga_source_ptr sinfo); 62 63 /* Result of read_pixel is delivered here: */ 64 U_CHAR tga_pixel[4]; 65 66 int pixel_size; /* Bytes per Targa pixel (1 to 4) */ 67 68 /* State info for reading RLE-coded pixels; both counts must be init to 0 */ 69 int block_count; /* # of pixels remaining in RLE block */ 70 int dup_pixel_count; /* # of times to duplicate previous pixel */ 71 72 /* This saves the correct pixel-row-expansion method for preload_image */ 73 JDIMENSION (*get_pixel_rows) (j_compress_ptr cinfo, cjpeg_source_ptr sinfo); 74 } tga_source_struct; 75 76 77 /* For expanding 5-bit pixel values to 8-bit with best rounding */ 78 79 static const UINT8 c5to8bits[32] = { 80 0, 8, 16, 25, 33, 41, 49, 58, 81 66, 74, 82, 90, 99, 107, 115, 123, 82 132, 140, 148, 156, 165, 173, 181, 189, 83 197, 206, 214, 222, 230, 239, 247, 255 84 }; 85 86 87 88 LOCAL(int) 89 read_byte (tga_source_ptr sinfo) 90 /* Read next byte from Targa file */ 91 { 92 register FILE *infile = sinfo->pub.input_file; 93 register int c; 94 95 if ((c = getc(infile)) == EOF) 96 ERREXIT(sinfo->cinfo, JERR_INPUT_EOF); 97 return c; 98 } 99 100 101 LOCAL(void) 102 read_colormap (tga_source_ptr sinfo, int cmaplen, int mapentrysize) 103 /* Read the colormap from a Targa file */ 104 { 105 int i; 106 107 /* Presently only handles 24-bit BGR format */ 108 if (mapentrysize != 24) 109 ERREXIT(sinfo->cinfo, JERR_TGA_BADCMAP); 110 111 for (i = 0; i < cmaplen; i++) { 112 sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo); 113 sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo); 114 sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo); 115 } 116 } 117 118 119 /* 120 * read_pixel methods: get a single pixel from Targa file into tga_pixel[] 121 */ 122 123 METHODDEF(void) 124 read_non_rle_pixel (tga_source_ptr sinfo) 125 /* Read one Targa pixel from the input file; no RLE expansion */ 126 { 127 register FILE *infile = sinfo->pub.input_file; 128 register int i; 129 130 for (i = 0; i < sinfo->pixel_size; i++) { 131 sinfo->tga_pixel[i] = (U_CHAR) getc(infile); 132 } 133 } 134 135 136 METHODDEF(void) 137 read_rle_pixel (tga_source_ptr sinfo) 138 /* Read one Targa pixel from the input file, expanding RLE data as needed */ 139 { 140 register FILE *infile = sinfo->pub.input_file; 141 register int i; 142 143 /* Duplicate previously read pixel? */ 144 if (sinfo->dup_pixel_count > 0) { 145 sinfo->dup_pixel_count--; 146 return; 147 } 148 149 /* Time to read RLE block header? */ 150 if (--sinfo->block_count < 0) { /* decrement pixels remaining in block */ 151 i = read_byte(sinfo); 152 if (i & 0x80) { /* Start of duplicate-pixel block? */ 153 sinfo->dup_pixel_count = i & 0x7F; /* number of dups after this one */ 154 sinfo->block_count = 0; /* then read new block header */ 155 } else { 156 sinfo->block_count = i & 0x7F; /* number of pixels after this one */ 157 } 158 } 159 160 /* Read next pixel */ 161 for (i = 0; i < sinfo->pixel_size; i++) { 162 sinfo->tga_pixel[i] = (U_CHAR) getc(infile); 163 } 164 } 165 166 167 /* 168 * Read one row of pixels. 169 * 170 * We provide several different versions depending on input file format. 171 */ 172 173 174 METHODDEF(JDIMENSION) 175 get_8bit_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 176 /* This version is for reading 8-bit grayscale pixels */ 177 { 178 tga_source_ptr source = (tga_source_ptr) sinfo; 179 register JSAMPROW ptr; 180 register JDIMENSION col; 181 182 ptr = source->pub.buffer[0]; 183 for (col = cinfo->image_width; col > 0; col--) { 184 (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ 185 *ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]); 186 } 187 return 1; 188 } 189 190 METHODDEF(JDIMENSION) 191 get_8bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 192 /* This version is for reading 8-bit colormap indexes */ 193 { 194 tga_source_ptr source = (tga_source_ptr) sinfo; 195 register int t; 196 register JSAMPROW ptr; 197 register JDIMENSION col; 198 register JSAMPARRAY colormap = source->colormap; 199 200 ptr = source->pub.buffer[0]; 201 for (col = cinfo->image_width; col > 0; col--) { 202 (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ 203 t = UCH(source->tga_pixel[0]); 204 *ptr++ = colormap[0][t]; 205 *ptr++ = colormap[1][t]; 206 *ptr++ = colormap[2][t]; 207 } 208 return 1; 209 } 210 211 METHODDEF(JDIMENSION) 212 get_16bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 213 /* This version is for reading 16-bit pixels */ 214 { 215 tga_source_ptr source = (tga_source_ptr) sinfo; 216 register int t; 217 register JSAMPROW ptr; 218 register JDIMENSION col; 219 220 ptr = source->pub.buffer[0]; 221 for (col = cinfo->image_width; col > 0; col--) { 222 (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ 223 t = UCH(source->tga_pixel[0]); 224 t += UCH(source->tga_pixel[1]) << 8; 225 /* We expand 5 bit data to 8 bit sample width. 226 * The format of the 16-bit (LSB first) input word is 227 * xRRRRRGGGGGBBBBB 228 */ 229 ptr[2] = (JSAMPLE) c5to8bits[t & 0x1F]; 230 t >>= 5; 231 ptr[1] = (JSAMPLE) c5to8bits[t & 0x1F]; 232 t >>= 5; 233 ptr[0] = (JSAMPLE) c5to8bits[t & 0x1F]; 234 ptr += 3; 235 } 236 return 1; 237 } 238 239 METHODDEF(JDIMENSION) 240 get_24bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 241 /* This version is for reading 24-bit pixels */ 242 { 243 tga_source_ptr source = (tga_source_ptr) sinfo; 244 register JSAMPROW ptr; 245 register JDIMENSION col; 246 247 ptr = source->pub.buffer[0]; 248 for (col = cinfo->image_width; col > 0; col--) { 249 (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ 250 *ptr++ = (JSAMPLE) UCH(source->tga_pixel[2]); /* change BGR to RGB order */ 251 *ptr++ = (JSAMPLE) UCH(source->tga_pixel[1]); 252 *ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]); 253 } 254 return 1; 255 } 256 257 /* 258 * Targa also defines a 32-bit pixel format with order B,G,R,A. 259 * We presently ignore the attribute byte, so the code for reading 260 * these pixels is identical to the 24-bit routine above. 261 * This works because the actual pixel length is only known to read_pixel. 262 */ 263 264 #define get_32bit_row get_24bit_row 265 266 267 /* 268 * This method is for re-reading the input data in standard top-down 269 * row order. The entire image has already been read into whole_image 270 * with proper conversion of pixel format, but it's in a funny row order. 271 */ 272 273 METHODDEF(JDIMENSION) 274 get_memory_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 275 { 276 tga_source_ptr source = (tga_source_ptr) sinfo; 277 JDIMENSION source_row; 278 279 /* Compute row of source that maps to current_row of normal order */ 280 /* For now, assume image is bottom-up and not interlaced. */ 281 /* NEEDS WORK to support interlaced images! */ 282 source_row = cinfo->image_height - source->current_row - 1; 283 284 /* Fetch that row from virtual array */ 285 source->pub.buffer = (*cinfo->mem->access_virt_sarray) 286 ((j_common_ptr) cinfo, source->whole_image, 287 source_row, (JDIMENSION) 1, FALSE); 288 289 source->current_row++; 290 return 1; 291 } 292 293 294 /* 295 * This method loads the image into whole_image during the first call on 296 * get_pixel_rows. The get_pixel_rows pointer is then adjusted to call 297 * get_memory_row on subsequent calls. 298 */ 299 300 METHODDEF(JDIMENSION) 301 preload_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 302 { 303 tga_source_ptr source = (tga_source_ptr) sinfo; 304 JDIMENSION row; 305 cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; 306 307 /* Read the data into a virtual array in input-file row order. */ 308 for (row = 0; row < cinfo->image_height; row++) { 309 if (progress != NULL) { 310 progress->pub.pass_counter = (long) row; 311 progress->pub.pass_limit = (long) cinfo->image_height; 312 (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); 313 } 314 source->pub.buffer = (*cinfo->mem->access_virt_sarray) 315 ((j_common_ptr) cinfo, source->whole_image, row, (JDIMENSION) 1, TRUE); 316 (*source->get_pixel_rows) (cinfo, sinfo); 317 } 318 if (progress != NULL) 319 progress->completed_extra_passes++; 320 321 /* Set up to read from the virtual array in unscrambled order */ 322 source->pub.get_pixel_rows = get_memory_row; 323 source->current_row = 0; 324 /* And read the first row */ 325 return get_memory_row(cinfo, sinfo); 326 } 327 328 329 /* 330 * Read the file header; return image size and component count. 331 */ 332 333 METHODDEF(void) 334 start_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 335 { 336 tga_source_ptr source = (tga_source_ptr) sinfo; 337 U_CHAR targaheader[18]; 338 int idlen, cmaptype, subtype, flags, interlace_type, components; 339 unsigned int width, height, maplen; 340 boolean is_bottom_up; 341 342 #define GET_2B(offset) ((unsigned int) UCH(targaheader[offset]) + \ 343 (((unsigned int) UCH(targaheader[offset+1])) << 8)) 344 345 if (! ReadOK(source->pub.input_file, targaheader, 18)) 346 ERREXIT(cinfo, JERR_INPUT_EOF); 347 348 /* Pretend "15-bit" pixels are 16-bit --- we ignore attribute bit anyway */ 349 if (targaheader[16] == 15) 350 targaheader[16] = 16; 351 352 idlen = UCH(targaheader[0]); 353 cmaptype = UCH(targaheader[1]); 354 subtype = UCH(targaheader[2]); 355 maplen = GET_2B(5); 356 width = GET_2B(12); 357 height = GET_2B(14); 358 source->pixel_size = UCH(targaheader[16]) >> 3; 359 flags = UCH(targaheader[17]); /* Image Descriptor byte */ 360 361 is_bottom_up = ((flags & 0x20) == 0); /* bit 5 set => top-down */ 362 interlace_type = flags >> 6; /* bits 6/7 are interlace code */ 363 364 if (cmaptype > 1 || /* cmaptype must be 0 or 1 */ 365 source->pixel_size < 1 || source->pixel_size > 4 || 366 (UCH(targaheader[16]) & 7) != 0 || /* bits/pixel must be multiple of 8 */ 367 interlace_type != 0 || /* currently don't allow interlaced image */ 368 width == 0 || height == 0) /* image width/height must be non-zero */ 369 ERREXIT(cinfo, JERR_TGA_BADPARMS); 370 371 if (subtype > 8) { 372 /* It's an RLE-coded file */ 373 source->read_pixel = read_rle_pixel; 374 source->block_count = source->dup_pixel_count = 0; 375 subtype -= 8; 376 } else { 377 /* Non-RLE file */ 378 source->read_pixel = read_non_rle_pixel; 379 } 380 381 /* Now should have subtype 1, 2, or 3 */ 382 components = 3; /* until proven different */ 383 cinfo->in_color_space = JCS_RGB; 384 385 switch (subtype) { 386 case 1: /* Colormapped image */ 387 if (source->pixel_size == 1 && cmaptype == 1) 388 source->get_pixel_rows = get_8bit_row; 389 else 390 ERREXIT(cinfo, JERR_TGA_BADPARMS); 391 TRACEMS2(cinfo, 1, JTRC_TGA_MAPPED, width, height); 392 break; 393 case 2: /* RGB image */ 394 switch (source->pixel_size) { 395 case 2: 396 source->get_pixel_rows = get_16bit_row; 397 break; 398 case 3: 399 source->get_pixel_rows = get_24bit_row; 400 break; 401 case 4: 402 source->get_pixel_rows = get_32bit_row; 403 break; 404 default: 405 ERREXIT(cinfo, JERR_TGA_BADPARMS); 406 break; 407 } 408 TRACEMS2(cinfo, 1, JTRC_TGA, width, height); 409 break; 410 case 3: /* Grayscale image */ 411 components = 1; 412 cinfo->in_color_space = JCS_GRAYSCALE; 413 if (source->pixel_size == 1) 414 source->get_pixel_rows = get_8bit_gray_row; 415 else 416 ERREXIT(cinfo, JERR_TGA_BADPARMS); 417 TRACEMS2(cinfo, 1, JTRC_TGA_GRAY, width, height); 418 break; 419 default: 420 ERREXIT(cinfo, JERR_TGA_BADPARMS); 421 break; 422 } 423 424 if (is_bottom_up) { 425 /* Create a virtual array to buffer the upside-down image. */ 426 source->whole_image = (*cinfo->mem->request_virt_sarray) 427 ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, 428 (JDIMENSION) width * components, (JDIMENSION) height, (JDIMENSION) 1); 429 if (cinfo->progress != NULL) { 430 cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; 431 progress->total_extra_passes++; /* count file input as separate pass */ 432 } 433 /* source->pub.buffer will point to the virtual array. */ 434 source->pub.buffer_height = 1; /* in case anyone looks at it */ 435 source->pub.get_pixel_rows = preload_image; 436 } else { 437 /* Don't need a virtual array, but do need a one-row input buffer. */ 438 source->whole_image = NULL; 439 source->pub.buffer = (*cinfo->mem->alloc_sarray) 440 ((j_common_ptr) cinfo, JPOOL_IMAGE, 441 (JDIMENSION) width * components, (JDIMENSION) 1); 442 source->pub.buffer_height = 1; 443 source->pub.get_pixel_rows = source->get_pixel_rows; 444 } 445 446 while (idlen--) /* Throw away ID field */ 447 (void) read_byte(source); 448 449 if (maplen > 0) { 450 if (maplen > 256 || GET_2B(3) != 0) 451 ERREXIT(cinfo, JERR_TGA_BADCMAP); 452 /* Allocate space to store the colormap */ 453 source->colormap = (*cinfo->mem->alloc_sarray) 454 ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) maplen, (JDIMENSION) 3); 455 /* and read it from the file */ 456 read_colormap(source, (int) maplen, UCH(targaheader[7])); 457 } else { 458 if (cmaptype) /* but you promised a cmap! */ 459 ERREXIT(cinfo, JERR_TGA_BADPARMS); 460 source->colormap = NULL; 461 } 462 463 cinfo->input_components = components; 464 cinfo->data_precision = 8; 465 cinfo->image_width = width; 466 cinfo->image_height = height; 467 } 468 469 470 /* 471 * Finish up at the end of the file. 472 */ 473 474 METHODDEF(void) 475 finish_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 476 { 477 /* no work */ 478 } 479 480 481 /* 482 * The module selection routine for Targa format input. 483 */ 484 485 GLOBAL(cjpeg_source_ptr) 486 jinit_read_targa (j_compress_ptr cinfo) 487 { 488 tga_source_ptr source; 489 490 /* Create module interface object */ 491 source = (tga_source_ptr) 492 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 493 sizeof(tga_source_struct)); 494 source->cinfo = cinfo; /* make back link for subroutines */ 495 /* Fill in method ptrs, except get_pixel_rows which start_input sets */ 496 source->pub.start_input = start_input_tga; 497 source->pub.finish_input = finish_input_tga; 498 499 return (cjpeg_source_ptr) source; 500 } 501 502 #endif /* TARGA_SUPPORTED */ 503
