ref: a00b6bdbfa72a1688a866edf5f825720c9874ada
dir: /sys/src/cmd/gs/jpeg/rdrle.c/
/* * rdrle.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to read input images in Utah RLE format. * The Utah Raster Toolkit library is required (version 3.1 or later). * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume input from * an ordinary stdio stream. They further assume that reading begins * at the start of the file; start_input may need work if the * user interface has already read some data (e.g., to determine that * the file is indeed RLE format). * * Based on code contributed by Mike Lijewski, * with updates from Robert Hutchinson. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef RLE_SUPPORTED /* rle.h is provided by the Utah Raster Toolkit. */ #include <rle.h> /* * We assume that JSAMPLE has the same representation as rle_pixel, * to wit, "unsigned char". Hence we can't cope with 12- or 16-bit samples. */ #if BITS_IN_JSAMPLE != 8 Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */ #endif /* * We support the following types of RLE files: * * GRAYSCALE - 8 bits, no colormap * MAPPEDGRAY - 8 bits, 1 channel colomap * PSEUDOCOLOR - 8 bits, 3 channel colormap * TRUECOLOR - 24 bits, 3 channel colormap * DIRECTCOLOR - 24 bits, no colormap * * For now, we ignore any alpha channel in the image. */ typedef enum { GRAYSCALE, MAPPEDGRAY, PSEUDOCOLOR, TRUECOLOR, DIRECTCOLOR } rle_kind; /* * Since RLE stores scanlines bottom-to-top, we have to invert the image * to conform to JPEG's top-to-bottom order. To do this, we read the * incoming image into a virtual array on the first get_pixel_rows call, * then fetch the required row from the virtual array on subsequent calls. */ typedef struct _rle_source_struct * rle_source_ptr; typedef struct _rle_source_struct { struct cjpeg_source_struct pub; /* public fields */ rle_kind visual; /* actual type of input file */ jvirt_sarray_ptr image; /* virtual array to hold the image */ JDIMENSION row; /* current row # in the virtual array */ rle_hdr header; /* Input file information */ rle_pixel** rle_row; /* holds a row returned by rle_getrow() */ } rle_source_struct; /* * Read the file header; return image size and component count. */ METHODDEF(void) start_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; JDIMENSION width, height; #ifdef PROGRESS_REPORT cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; #endif /* Use RLE library routine to get the header info */ source->header = *rle_hdr_init(NULL); source->header.rle_file = source->pub.input_file; switch (rle_get_setup(&(source->header))) { case RLE_SUCCESS: /* A-OK */ break; case RLE_NOT_RLE: ERREXIT(cinfo, JERR_RLE_NOT); break; case RLE_NO_SPACE: ERREXIT(cinfo, JERR_RLE_MEM); break; case RLE_EMPTY: ERREXIT(cinfo, JERR_RLE_EMPTY); break; case RLE_EOF: ERREXIT(cinfo, JERR_RLE_EOF); break; default: ERREXIT(cinfo, JERR_RLE_BADERROR); break; } /* Figure out what we have, set private vars and return values accordingly */ width = source->header.xmax - source->header.xmin + 1; height = source->header.ymax - source->header.ymin + 1; source->header.xmin = 0; /* realign horizontally */ source->header.xmax = width-1; cinfo->image_width = width; cinfo->image_height = height; cinfo->data_precision = 8; /* we can only handle 8 bit data */ if (source->header.ncolors == 1 && source->header.ncmap == 0) { source->visual = GRAYSCALE; TRACEMS2(cinfo, 1, JTRC_RLE_GRAY, width, height); } else if (source->header.ncolors == 1 && source->header.ncmap == 1) { source->visual = MAPPEDGRAY; TRACEMS3(cinfo, 1, JTRC_RLE_MAPGRAY, width, height, 1 << source->header.cmaplen); } else if (source->header.ncolors == 1 && source->header.ncmap == 3) { source->visual = PSEUDOCOLOR; TRACEMS3(cinfo, 1, JTRC_RLE_MAPPED, width, height, 1 << source->header.cmaplen); } else if (source->header.ncolors == 3 && source->header.ncmap == 3) { source->visual = TRUECOLOR; TRACEMS3(cinfo, 1, JTRC_RLE_FULLMAP, width, height, 1 << source->header.cmaplen); } else if (source->header.ncolors == 3 && source->header.ncmap == 0) { source->visual = DIRECTCOLOR; TRACEMS2(cinfo, 1, JTRC_RLE, width, height); } else ERREXIT(cinfo, JERR_RLE_UNSUPPORTED); if (source->visual == GRAYSCALE || source->visual == MAPPEDGRAY) { cinfo->in_color_space = JCS_GRAYSCALE; cinfo->input_components = 1; } else { cinfo->in_color_space = JCS_RGB; cinfo->input_components = 3; } /* * A place to hold each scanline while it's converted. * (GRAYSCALE scanlines don't need converting) */ if (source->visual != GRAYSCALE) { source->rle_row = (rle_pixel**) (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) width, (JDIMENSION) cinfo->input_components); } /* request a virtual array to hold the image */ source->image = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, (JDIMENSION) (width * source->header.ncolors), (JDIMENSION) height, (JDIMENSION) 1); #ifdef PROGRESS_REPORT if (progress != NULL) { /* count file input as separate pass */ progress->total_extra_passes++; } #endif source->pub.buffer_height = 1; } /* * Read one row of pixels. * Called only after load_image has read the image into the virtual array. * Used for GRAYSCALE, MAPPEDGRAY, TRUECOLOR, and DIRECTCOLOR images. */ METHODDEF(JDIMENSION) get_rle_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; source->row--; source->pub.buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE); return 1; } /* * Read one row of pixels. * Called only after load_image has read the image into the virtual array. * Used for PSEUDOCOLOR images. */ METHODDEF(JDIMENSION) get_pseudocolor_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; JSAMPROW src_row, dest_row; JDIMENSION col; rle_map *colormap; int val; colormap = source->header.cmap; dest_row = source->pub.buffer[0]; source->row--; src_row = * (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE); for (col = cinfo->image_width; col > 0; col--) { val = GETJSAMPLE(*src_row++); *dest_row++ = (JSAMPLE) (colormap[val ] >> 8); *dest_row++ = (JSAMPLE) (colormap[val + 256] >> 8); *dest_row++ = (JSAMPLE) (colormap[val + 512] >> 8); } return 1; } /* * Load the image into a virtual array. We have to do this because RLE * files start at the lower left while the JPEG standard has them starting * in the upper left. This is called the first time we want to get a row * of input. What we do is load the RLE data into the array and then call * the appropriate routine to read one row from the array. Before returning, * we set source->pub.get_pixel_rows so that subsequent calls go straight to * the appropriate row-reading routine. */ METHODDEF(JDIMENSION) load_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; JDIMENSION row, col; JSAMPROW scanline, red_ptr, green_ptr, blue_ptr; rle_pixel **rle_row; rle_map *colormap; char channel; #ifdef PROGRESS_REPORT cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; #endif colormap = source->header.cmap; rle_row = source->rle_row; /* Read the RLE data into our virtual array. * We assume here that (a) rle_pixel is represented the same as JSAMPLE, * and (b) we are not on a machine where FAR pointers differ from regular. */ RLE_CLR_BIT(source->header, RLE_ALPHA); /* don't read the alpha channel */ #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_limit = cinfo->image_height; progress->pub.pass_counter = 0; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif switch (source->visual) { case GRAYSCALE: case PSEUDOCOLOR: for (row = 0; row < cinfo->image_height; row++) { rle_row = (rle_pixel **) (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); rle_getrow(&source->header, rle_row); #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } break; case MAPPEDGRAY: case TRUECOLOR: for (row = 0; row < cinfo->image_height; row++) { scanline = * (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); rle_row = source->rle_row; rle_getrow(&source->header, rle_row); for (col = 0; col < cinfo->image_width; col++) { for (channel = 0; channel < source->header.ncolors; channel++) { *scanline++ = (JSAMPLE) (colormap[GETJSAMPLE(rle_row[channel][col]) + 256 * channel] >> 8); } } #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } break; case DIRECTCOLOR: for (row = 0; row < cinfo->image_height; row++) { scanline = * (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); rle_getrow(&source->header, rle_row); red_ptr = rle_row[0]; green_ptr = rle_row[1]; blue_ptr = rle_row[2]; for (col = cinfo->image_width; col > 0; col--) { *scanline++ = *red_ptr++; *scanline++ = *green_ptr++; *scanline++ = *blue_ptr++; } #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } } #ifdef PROGRESS_REPORT if (progress != NULL) progress->completed_extra_passes++; #endif /* Set up to call proper row-extraction routine in future */ if (source->visual == PSEUDOCOLOR) { source->pub.buffer = source->rle_row; source->pub.get_pixel_rows = get_pseudocolor_row; } else { source->pub.get_pixel_rows = get_rle_row; } source->row = cinfo->image_height; /* And fetch the topmost (bottommost) row */ return (*source->pub.get_pixel_rows) (cinfo, sinfo); } /* * Finish up at the end of the file. */ METHODDEF(void) finish_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { /* no work */ } /* * The module selection routine for RLE format input. */ GLOBAL(cjpeg_source_ptr) jinit_read_rle (j_compress_ptr cinfo) { rle_source_ptr source; /* Create module interface object */ source = (rle_source_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(rle_source_struct)); /* Fill in method ptrs */ source->pub.start_input = start_input_rle; source->pub.finish_input = finish_input_rle; source->pub.get_pixel_rows = load_image; return (cjpeg_source_ptr) source; } #endif /* RLE_SUPPORTED */