blob: 542bc37490cc563f89da25a686144099984496d8 [file] [log] [blame]
Dees_Troy51a0e822012-09-05 15:24:24 -04001/*
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
51typedef 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
62typedef struct _rle_source_struct * rle_source_ptr;
63
64typedef 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
80METHODDEF(void)
81start_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
186METHODDEF(JDIMENSION)
187get_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
204METHODDEF(JDIMENSION)
205get_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
240METHODDEF(JDIMENSION)
241load_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
359METHODDEF(void)
360finish_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
370GLOBAL(cjpeg_source_ptr)
371jinit_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 */