]> git.jsancho.org Git - lugaru.git/blob - jpeg-6b/rdrle.c
Changed data dir mentioned in makefile.
[lugaru.git] / jpeg-6b / rdrle.c
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 */