rdrle.c
Go to the documentation of this file.
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;
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 
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 
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 
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 
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 */
char JSAMPLE
Definition: jmorecfg.h:64
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:66
#define FALSE
Definition: OPC_IceHook.h:9
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:261
#define GETJSAMPLE(value)
Definition: jmorecfg.h:68
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
#define TRACEMS2(cinfo, lvl, code, p1, p2)
Definition: jerror.h:259
#define TRUE
Definition: OPC_IceHook.h:13
#define SIZEOF(object)
Definition: jinclude.h:80
png_bytepp image
Definition: png.h:1772
#define JPOOL_IMAGE
Definition: jpeglib.h:749
png_infop png_uint_32 * width
Definition: png.h:2309
int total_extra_passes
Definition: cdjpeg.h:84
int JSAMPARRAY int dest_row
Definition: jpegint.h:373
png_infop png_uint_32 png_uint_32 * height
Definition: png.h:2309
int val
Definition: jpeglib.h:956
png_bytepp row
Definition: png.h:1759
struct jpeg_progress_mgr pub
Definition: cdjpeg.h:82
Definition: inftrees.h:24
#define GLOBAL(type)
Definition: jmorecfg.h:188
#define METHODDEF(type)
Definition: jmorecfg.h:184
int completed_extra_passes
Definition: cdjpeg.h:83
cd_progress_ptr progress
Definition: cdjpeg.h:147
#define TRACEMS3(cinfo, lvl, code, p1, p2, p3)
Definition: jerror.h:264
unsigned int JDIMENSION
Definition: jmorecfg.h:171
struct cdjpeg_progress_mgr * cd_progress_ptr
Definition: cdjpeg.h:89


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat Apr 13 2019 02:14:25