[LIBJPEG] Update to version 9c. CORE-14291
[reactos.git] / dll / 3rdparty / libjpeg / rdppm.c
1 /*
2 * rdppm.c
3 *
4 * Copyright (C) 1991-1997, Thomas G. Lane.
5 * Modified 2009-2017 by Bill Allombert, Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
8 *
9 * This file contains routines to read input images in PPM/PGM format.
10 * The extended 2-byte-per-sample raw PPM/PGM formats are supported.
11 * The PBMPLUS library is NOT required to compile this software
12 * (but it is highly useful as a set of PPM image manipulation programs).
13 *
14 * These routines may need modification for non-Unix environments or
15 * specialized applications. As they stand, they assume input from
16 * an ordinary stdio stream. They further assume that reading begins
17 * at the start of the file; start_input may need work if the
18 * user interface has already read some data (e.g., to determine that
19 * the file is indeed PPM format).
20 */
21
22 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
23
24 #ifdef PPM_SUPPORTED
25
26
27 /* Portions of this code are based on the PBMPLUS library, which is:
28 **
29 ** Copyright (C) 1988 by Jef Poskanzer.
30 **
31 ** Permission to use, copy, modify, and distribute this software and its
32 ** documentation for any purpose and without fee is hereby granted, provided
33 ** that the above copyright notice appear in all copies and that both that
34 ** copyright notice and this permission notice appear in supporting
35 ** documentation. This software is provided "as is" without express or
36 ** implied warranty.
37 */
38
39
40 /* Macros to deal with unsigned chars as efficiently as compiler allows */
41
42 #ifdef HAVE_UNSIGNED_CHAR
43 typedef unsigned char U_CHAR;
44 #define UCH(x) ((int) (x))
45 #else /* !HAVE_UNSIGNED_CHAR */
46 #ifdef CHAR_IS_UNSIGNED
47 typedef char U_CHAR;
48 #define UCH(x) ((int) (x))
49 #else
50 typedef char U_CHAR;
51 #define UCH(x) ((int) (x) & 0xFF)
52 #endif
53 #endif /* HAVE_UNSIGNED_CHAR */
54
55
56 #define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))
57
58
59 /*
60 * On most systems, reading individual bytes with getc() is drastically less
61 * efficient than buffering a row at a time with fread(). On PCs, we must
62 * allocate the buffer in near data space, because we are assuming small-data
63 * memory model, wherein fread() can't reach far memory. If you need to
64 * process very wide images on a PC, you might have to compile in large-memory
65 * model, or else replace fread() with a getc() loop --- which will be much
66 * slower.
67 */
68
69
70 /* Private version of data source object */
71
72 typedef struct {
73 struct cjpeg_source_struct pub; /* public fields */
74
75 U_CHAR *iobuffer; /* non-FAR pointer to I/O buffer */
76 JSAMPROW pixrow; /* FAR pointer to same */
77 size_t buffer_width; /* width of I/O buffer */
78 JSAMPLE *rescale; /* => maxval-remapping array, or NULL */
79 unsigned int maxval;
80 } ppm_source_struct;
81
82 typedef ppm_source_struct * ppm_source_ptr;
83
84
85 LOCAL(int)
86 pbm_getc (FILE * infile)
87 /* Read next char, skipping over any comments */
88 /* A comment/newline sequence is returned as a newline */
89 {
90 register int ch;
91
92 ch = getc(infile);
93 if (ch == '#') {
94 do {
95 ch = getc(infile);
96 } while (ch != '\n' && ch != EOF);
97 }
98 return ch;
99 }
100
101
102 LOCAL(unsigned int)
103 read_pbm_integer (j_compress_ptr cinfo, FILE * infile)
104 /* Read an unsigned decimal integer from the PPM file */
105 /* Swallows one trailing character after the integer */
106 /* Note that on a 16-bit-int machine, only values up to 64k can be read. */
107 /* This should not be a problem in practice. */
108 {
109 register int ch;
110 register unsigned int val;
111
112 /* Skip any leading whitespace */
113 do {
114 ch = pbm_getc(infile);
115 if (ch == EOF)
116 ERREXIT(cinfo, JERR_INPUT_EOF);
117 } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
118
119 if (ch < '0' || ch > '9')
120 ERREXIT(cinfo, JERR_PPM_NONNUMERIC);
121
122 val = ch - '0';
123 while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
124 val *= 10;
125 val += ch - '0';
126 }
127 return val;
128 }
129
130
131 /*
132 * Read one row of pixels.
133 *
134 * We provide several different versions depending on input file format.
135 * In all cases, input is scaled to the size of JSAMPLE.
136 *
137 * A really fast path is provided for reading byte/sample raw files with
138 * maxval = MAXJSAMPLE, which is the normal case for 8-bit data.
139 */
140
141
142 METHODDEF(JDIMENSION)
143 get_text_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
144 /* This version is for reading text-format PGM files with any maxval */
145 {
146 ppm_source_ptr source = (ppm_source_ptr) sinfo;
147 FILE * infile = source->pub.input_file;
148 register JSAMPROW ptr;
149 register JSAMPLE *rescale = source->rescale;
150 unsigned int maxval = source->maxval;
151 JDIMENSION col;
152
153 ptr = source->pub.buffer[0];
154 for (col = cinfo->image_width; col > 0; col--) {
155 register unsigned int temp;
156 temp = read_pbm_integer(cinfo, infile);
157 if (temp > maxval)
158 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
159 *ptr++ = rescale[temp];
160 }
161 return 1;
162 }
163
164
165 METHODDEF(JDIMENSION)
166 get_text_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
167 /* This version is for reading text-format PPM files with any maxval */
168 {
169 ppm_source_ptr source = (ppm_source_ptr) sinfo;
170 FILE * infile = source->pub.input_file;
171 register JSAMPROW ptr;
172 register JSAMPLE *rescale = source->rescale;
173 unsigned int maxval = source->maxval;
174 JDIMENSION col;
175
176 ptr = source->pub.buffer[0];
177 for (col = cinfo->image_width; col > 0; col--) {
178 register unsigned int temp;
179 temp = read_pbm_integer(cinfo, infile);
180 if (temp > maxval)
181 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
182 *ptr++ = rescale[temp];
183 temp = read_pbm_integer(cinfo, infile);
184 if (temp > maxval)
185 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
186 *ptr++ = rescale[temp];
187 temp = read_pbm_integer(cinfo, infile);
188 if (temp > maxval)
189 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
190 *ptr++ = rescale[temp];
191 }
192 return 1;
193 }
194
195
196 METHODDEF(JDIMENSION)
197 get_scaled_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
198 /* This version is for reading raw-byte-format PGM files with any maxval */
199 {
200 ppm_source_ptr source = (ppm_source_ptr) sinfo;
201 register JSAMPROW ptr;
202 register U_CHAR * bufferptr;
203 register JSAMPLE *rescale = source->rescale;
204 unsigned int maxval = source->maxval;
205 JDIMENSION col;
206
207 if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
208 ERREXIT(cinfo, JERR_INPUT_EOF);
209 ptr = source->pub.buffer[0];
210 bufferptr = source->iobuffer;
211 for (col = cinfo->image_width; col > 0; col--) {
212 register unsigned int temp;
213 temp = (unsigned int) UCH(*bufferptr++);
214 if (temp > maxval)
215 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
216 *ptr++ = rescale[temp];
217 }
218 return 1;
219 }
220
221
222 METHODDEF(JDIMENSION)
223 get_scaled_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
224 /* This version is for reading raw-byte-format PPM files with any maxval */
225 {
226 ppm_source_ptr source = (ppm_source_ptr) sinfo;
227 register JSAMPROW ptr;
228 register U_CHAR * bufferptr;
229 register JSAMPLE *rescale = source->rescale;
230 unsigned int maxval = source->maxval;
231 JDIMENSION col;
232
233 if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
234 ERREXIT(cinfo, JERR_INPUT_EOF);
235 ptr = source->pub.buffer[0];
236 bufferptr = source->iobuffer;
237 for (col = cinfo->image_width; col > 0; col--) {
238 register unsigned int temp;
239 temp = (unsigned int) UCH(*bufferptr++);
240 if (temp > maxval)
241 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
242 *ptr++ = rescale[temp];
243 temp = (unsigned int) UCH(*bufferptr++);
244 if (temp > maxval)
245 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
246 *ptr++ = rescale[temp];
247 temp = (unsigned int) UCH(*bufferptr++);
248 if (temp > maxval)
249 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
250 *ptr++ = rescale[temp];
251 }
252 return 1;
253 }
254
255
256 METHODDEF(JDIMENSION)
257 get_raw_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
258 /* This version is for reading raw-byte-format files with maxval = MAXJSAMPLE.
259 * In this case we just read right into the JSAMPLE buffer!
260 * Note that same code works for PPM and PGM files.
261 */
262 {
263 ppm_source_ptr source = (ppm_source_ptr) sinfo;
264
265 if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
266 ERREXIT(cinfo, JERR_INPUT_EOF);
267 return 1;
268 }
269
270
271 METHODDEF(JDIMENSION)
272 get_word_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
273 /* This version is for reading raw-word-format PGM files with any maxval */
274 {
275 ppm_source_ptr source = (ppm_source_ptr) sinfo;
276 register JSAMPROW ptr;
277 register U_CHAR * bufferptr;
278 register JSAMPLE *rescale = source->rescale;
279 unsigned int maxval = source->maxval;
280 JDIMENSION col;
281
282 if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
283 ERREXIT(cinfo, JERR_INPUT_EOF);
284 ptr = source->pub.buffer[0];
285 bufferptr = source->iobuffer;
286 for (col = cinfo->image_width; col > 0; col--) {
287 register unsigned int temp;
288 temp = ((unsigned int) UCH(*bufferptr++)) << 8;
289 temp |= (unsigned int) UCH(*bufferptr++);
290 if (temp > maxval)
291 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
292 *ptr++ = rescale[temp];
293 }
294 return 1;
295 }
296
297
298 METHODDEF(JDIMENSION)
299 get_word_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
300 /* This version is for reading raw-word-format PPM files with any maxval */
301 {
302 ppm_source_ptr source = (ppm_source_ptr) sinfo;
303 register JSAMPROW ptr;
304 register U_CHAR * bufferptr;
305 register JSAMPLE *rescale = source->rescale;
306 unsigned int maxval = source->maxval;
307 JDIMENSION col;
308
309 if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
310 ERREXIT(cinfo, JERR_INPUT_EOF);
311 ptr = source->pub.buffer[0];
312 bufferptr = source->iobuffer;
313 for (col = cinfo->image_width; col > 0; col--) {
314 register unsigned int temp;
315 temp = ((unsigned int) UCH(*bufferptr++)) << 8;
316 temp |= (unsigned int) UCH(*bufferptr++);
317 if (temp > maxval)
318 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
319 *ptr++ = rescale[temp];
320 temp = ((unsigned int) UCH(*bufferptr++)) << 8;
321 temp |= (unsigned int) UCH(*bufferptr++);
322 if (temp > maxval)
323 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
324 *ptr++ = rescale[temp];
325 temp = ((unsigned int) UCH(*bufferptr++)) << 8;
326 temp |= (unsigned int) UCH(*bufferptr++);
327 if (temp > maxval)
328 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
329 *ptr++ = rescale[temp];
330 }
331 return 1;
332 }
333
334
335 /*
336 * Read the file header; return image size and component count.
337 */
338
339 METHODDEF(void)
340 start_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
341 {
342 ppm_source_ptr source = (ppm_source_ptr) sinfo;
343 int c;
344 unsigned int w, h, maxval;
345 boolean need_iobuffer, use_raw_buffer, need_rescale;
346
347 if (getc(source->pub.input_file) != 'P')
348 ERREXIT(cinfo, JERR_PPM_NOT);
349
350 c = getc(source->pub.input_file); /* subformat discriminator character */
351
352 /* detect unsupported variants (ie, PBM) before trying to read header */
353 switch (c) {
354 case '2': /* it's a text-format PGM file */
355 case '3': /* it's a text-format PPM file */
356 case '5': /* it's a raw-format PGM file */
357 case '6': /* it's a raw-format PPM file */
358 break;
359 default:
360 ERREXIT(cinfo, JERR_PPM_NOT);
361 break;
362 }
363
364 /* fetch the remaining header info */
365 w = read_pbm_integer(cinfo, source->pub.input_file);
366 h = read_pbm_integer(cinfo, source->pub.input_file);
367 maxval = read_pbm_integer(cinfo, source->pub.input_file);
368
369 if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
370 ERREXIT(cinfo, JERR_PPM_NOT);
371
372 if (((long) w >> 24) || /* sanity check for buffer allocation below */
373 ((long) maxval >> 16)) /* support max 16-bit (2-byte) sample values */
374 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
375
376 cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */
377 cinfo->image_width = (JDIMENSION) w;
378 cinfo->image_height = (JDIMENSION) h;
379 source->maxval = maxval;
380
381 /* initialize flags to most common settings */
382 need_iobuffer = TRUE; /* do we need an I/O buffer? */
383 use_raw_buffer = FALSE; /* do we map input buffer onto I/O buffer? */
384 need_rescale = TRUE; /* do we need a rescale array? */
385
386 switch (c) {
387 case '2': /* it's a text-format PGM file */
388 cinfo->input_components = 1;
389 cinfo->in_color_space = JCS_GRAYSCALE;
390 TRACEMS2(cinfo, 1, JTRC_PGM_TEXT, w, h);
391 source->pub.get_pixel_rows = get_text_gray_row;
392 need_iobuffer = FALSE;
393 break;
394
395 case '3': /* it's a text-format PPM file */
396 cinfo->input_components = 3;
397 cinfo->in_color_space = JCS_RGB;
398 TRACEMS2(cinfo, 1, JTRC_PPM_TEXT, w, h);
399 source->pub.get_pixel_rows = get_text_rgb_row;
400 need_iobuffer = FALSE;
401 break;
402
403 case '5': /* it's a raw-format PGM file */
404 cinfo->input_components = 1;
405 cinfo->in_color_space = JCS_GRAYSCALE;
406 TRACEMS2(cinfo, 1, JTRC_PGM, w, h);
407 if (maxval > 255) {
408 source->pub.get_pixel_rows = get_word_gray_row;
409 } else if (maxval == MAXJSAMPLE && SIZEOF(JSAMPLE) == SIZEOF(U_CHAR)) {
410 source->pub.get_pixel_rows = get_raw_row;
411 use_raw_buffer = TRUE;
412 need_rescale = FALSE;
413 } else {
414 source->pub.get_pixel_rows = get_scaled_gray_row;
415 }
416 break;
417
418 case '6': /* it's a raw-format PPM file */
419 cinfo->input_components = 3;
420 cinfo->in_color_space = JCS_RGB;
421 TRACEMS2(cinfo, 1, JTRC_PPM, w, h);
422 if (maxval > 255) {
423 source->pub.get_pixel_rows = get_word_rgb_row;
424 } else if (maxval == MAXJSAMPLE && SIZEOF(JSAMPLE) == SIZEOF(U_CHAR)) {
425 source->pub.get_pixel_rows = get_raw_row;
426 use_raw_buffer = TRUE;
427 need_rescale = FALSE;
428 } else {
429 source->pub.get_pixel_rows = get_scaled_rgb_row;
430 }
431 break;
432 }
433
434 /* Allocate space for I/O buffer: 1 or 3 bytes or words/pixel. */
435 if (need_iobuffer) {
436 source->buffer_width = (size_t) w * cinfo->input_components *
437 ((maxval <= 255) ? SIZEOF(U_CHAR) : (2 * SIZEOF(U_CHAR)));
438 source->iobuffer = (U_CHAR *) (*cinfo->mem->alloc_small)
439 ((j_common_ptr) cinfo, JPOOL_IMAGE, source->buffer_width);
440 }
441
442 /* Create compressor input buffer. */
443 if (use_raw_buffer) {
444 /* For unscaled raw-input case, we can just map it onto the I/O buffer. */
445 /* Synthesize a JSAMPARRAY pointer structure */
446 /* Cast here implies near->far pointer conversion on PCs */
447 source->pixrow = (JSAMPROW) source->iobuffer;
448 source->pub.buffer = & source->pixrow;
449 source->pub.buffer_height = 1;
450 } else {
451 /* Need to translate anyway, so make a separate sample buffer. */
452 source->pub.buffer = (*cinfo->mem->alloc_sarray)
453 ((j_common_ptr) cinfo, JPOOL_IMAGE,
454 (JDIMENSION) w * cinfo->input_components, (JDIMENSION) 1);
455 source->pub.buffer_height = 1;
456 }
457
458 /* Compute the rescaling array if required. */
459 if (need_rescale) {
460 INT32 val, half_maxval;
461
462 /* On 16-bit-int machines we have to be careful of maxval = 65535 */
463 source->rescale = (JSAMPLE *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
464 JPOOL_IMAGE, (size_t) (((long) maxval + 1L) * SIZEOF(JSAMPLE)));
465 half_maxval = maxval / 2;
466 for (val = 0; val <= (INT32) maxval; val++) {
467 /* The multiplication here must be done in 32 bits to avoid overflow */
468 source->rescale[val] = (JSAMPLE) ((val * MAXJSAMPLE + half_maxval) / maxval);
469 }
470 }
471 }
472
473
474 /*
475 * Finish up at the end of the file.
476 */
477
478 METHODDEF(void)
479 finish_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
480 {
481 /* no work */
482 }
483
484
485 /*
486 * The module selection routine for PPM format input.
487 */
488
489 GLOBAL(cjpeg_source_ptr)
490 jinit_read_ppm (j_compress_ptr cinfo)
491 {
492 ppm_source_ptr source;
493
494 /* Create module interface object */
495 source = (ppm_source_ptr)
496 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
497 SIZEOF(ppm_source_struct));
498 /* Fill in method ptrs, except get_pixel_rows which start_input sets */
499 source->pub.start_input = start_input_ppm;
500 source->pub.finish_input = finish_input_ppm;
501
502 return &source->pub;
503 }
504
505 #endif /* PPM_SUPPORTED */