1 /*
2 * rdppm.c
3 *
4 * This file was part of the Independent JPEG Group's software:
5 * Copyright (C) 1991-1997, Thomas G. Lane.
6 * Modified 2009 by Bill Allombert, Guido Vollbeding.
7 * libjpeg-turbo Modifications:
8 * Copyright (C) 2015-2017, 2020-2022, D. R. Commander.
9 * For conditions of distribution and use, see the accompanying README.ijg
10 * file.
11 *
12 * This file contains routines to read input images in PPM/PGM format.
13 * The extended 2-byte-per-sample raw PPM/PGM formats are supported.
14 * The PBMPLUS library is NOT required to compile this software
15 * (but it is highly useful as a set of PPM image manipulation programs).
16 *
17 * These routines may need modification for non-Unix environments or
18 * specialized applications. As they stand, they assume input from
19 * an ordinary stdio stream. They further assume that reading begins
20 * at the start of the file; start_input may need work if the
21 * user interface has already read some data (e.g., to determine that
22 * the file is indeed PPM format).
23 */
24
25 #include "cmyk.h"
26 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
27
28 #ifdef PPM_SUPPORTED
29
30
31 /* Portions of this code are based on the PBMPLUS library, which is:
32 **
33 ** Copyright (C) 1988 by Jef Poskanzer.
34 **
35 ** Permission to use, copy, modify, and distribute this software and its
36 ** documentation for any purpose and without fee is hereby granted, provided
37 ** that the above copyright notice appear in all copies and that both that
38 ** copyright notice and this permission notice appear in supporting
39 ** documentation. This software is provided "as is" without express or
40 ** implied warranty.
41 */
42
43
44 /* Macros to deal with unsigned chars as efficiently as compiler allows */
45
46 typedef unsigned char U_CHAR;
47 #define UCH(x) ((int)(x))
48
49
50 #define ReadOK(file, buffer, len) \
51 (fread(buffer, 1, len, file) == ((size_t)(len)))
52
53 static int alpha_index[JPEG_NUMCS] = {
54 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1
55 };
56
57
58 /* Private version of data source object */
59
60 typedef struct {
61 struct cjpeg_source_struct pub; /* public fields */
62
63 /* Usually these two pointers point to the same place: */
64 U_CHAR *iobuffer; /* fread's I/O buffer */
65 JSAMPROW pixrow; /* compressor input buffer */
66 size_t buffer_width; /* width of I/O buffer */
67 JSAMPLE *rescale; /* => maxval-remapping array, or NULL */
68 unsigned int maxval;
69 } ppm_source_struct;
70
71 typedef ppm_source_struct *ppm_source_ptr;
72
73
74 LOCAL(int)
pbm_getc(FILE * infile)75 pbm_getc(FILE *infile)
76 /* Read next char, skipping over any comments */
77 /* A comment/newline sequence is returned as a newline */
78 {
79 register int ch;
80
81 ch = getc(infile);
82 if (ch == '#') {
83 do {
84 ch = getc(infile);
85 } while (ch != '\n' && ch != EOF);
86 }
87 return ch;
88 }
89
90
91 LOCAL(unsigned int)
read_pbm_integer(j_compress_ptr cinfo,FILE * infile,unsigned int maxval)92 read_pbm_integer(j_compress_ptr cinfo, FILE *infile, unsigned int maxval)
93 /* Read an unsigned decimal integer from the PPM file */
94 /* Swallows one trailing character after the integer */
95 /* Note that on a 16-bit-int machine, only values up to 64k can be read. */
96 /* This should not be a problem in practice. */
97 {
98 register int ch;
99 register unsigned int val;
100
101 /* Skip any leading whitespace */
102 do {
103 ch = pbm_getc(infile);
104 if (ch == EOF)
105 ERREXIT(cinfo, JERR_INPUT_EOF);
106 } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
107
108 if (ch < '0' || ch > '9')
109 ERREXIT(cinfo, JERR_PPM_NONNUMERIC);
110
111 val = ch - '0';
112 while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
113 val *= 10;
114 val += ch - '0';
115 if (val > maxval)
116 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
117 }
118
119 return val;
120 }
121
122
123 /*
124 * Read one row of pixels.
125 *
126 * We provide several different versions depending on input file format.
127 * In all cases, input is scaled to the size of JSAMPLE.
128 *
129 * A really fast path is provided for reading byte/sample raw files with
130 * maxval = MAXJSAMPLE, which is the normal case for 8-bit data.
131 */
132
133
134 METHODDEF(JDIMENSION)
get_text_gray_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)135 get_text_gray_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
136 /* This version is for reading text-format PGM files with any maxval */
137 {
138 ppm_source_ptr source = (ppm_source_ptr)sinfo;
139 FILE *infile = source->pub.input_file;
140 register JSAMPROW ptr;
141 register JSAMPLE *rescale = source->rescale;
142 JDIMENSION col;
143 unsigned int maxval = source->maxval;
144
145 ptr = source->pub.buffer[0];
146 for (col = cinfo->image_width; col > 0; col--) {
147 *ptr++ = rescale[read_pbm_integer(cinfo, infile, maxval)];
148 }
149 return 1;
150 }
151
152
153 #define GRAY_RGB_READ_LOOP(read_op, alpha_set_op) { \
154 for (col = cinfo->image_width; col > 0; col--) { \
155 ptr[rindex] = ptr[gindex] = ptr[bindex] = read_op; \
156 alpha_set_op \
157 ptr += ps; \
158 } \
159 }
160
161 METHODDEF(JDIMENSION)
get_text_gray_rgb_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)162 get_text_gray_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
163 /* This version is for reading text-format PGM files with any maxval and
164 converting to extended RGB */
165 {
166 ppm_source_ptr source = (ppm_source_ptr)sinfo;
167 FILE *infile = source->pub.input_file;
168 register JSAMPROW ptr;
169 register JSAMPLE *rescale = source->rescale;
170 JDIMENSION col;
171 unsigned int maxval = source->maxval;
172 register int rindex = rgb_red[cinfo->in_color_space];
173 register int gindex = rgb_green[cinfo->in_color_space];
174 register int bindex = rgb_blue[cinfo->in_color_space];
175 register int aindex = alpha_index[cinfo->in_color_space];
176 register int ps = rgb_pixelsize[cinfo->in_color_space];
177
178 ptr = source->pub.buffer[0];
179 if (maxval == MAXJSAMPLE) {
180 if (aindex >= 0)
181 GRAY_RGB_READ_LOOP((JSAMPLE)read_pbm_integer(cinfo, infile, maxval),
182 ptr[aindex] = 0xFF;)
183 else
184 GRAY_RGB_READ_LOOP((JSAMPLE)read_pbm_integer(cinfo, infile, maxval), {})
185 } else {
186 if (aindex >= 0)
187 GRAY_RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)],
188 ptr[aindex] = 0xFF;)
189 else
190 GRAY_RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)], {})
191 }
192 return 1;
193 }
194
195
196 METHODDEF(JDIMENSION)
get_text_gray_cmyk_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)197 get_text_gray_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
198 /* This version is for reading text-format PGM files with any maxval and
199 converting to CMYK */
200 {
201 ppm_source_ptr source = (ppm_source_ptr)sinfo;
202 FILE *infile = source->pub.input_file;
203 register JSAMPROW ptr;
204 register JSAMPLE *rescale = source->rescale;
205 JDIMENSION col;
206 unsigned int maxval = source->maxval;
207
208 ptr = source->pub.buffer[0];
209 if (maxval == MAXJSAMPLE) {
210 for (col = cinfo->image_width; col > 0; col--) {
211 JSAMPLE gray = (JSAMPLE)read_pbm_integer(cinfo, infile, maxval);
212 rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
213 ptr += 4;
214 }
215 } else {
216 for (col = cinfo->image_width; col > 0; col--) {
217 JSAMPLE gray = rescale[read_pbm_integer(cinfo, infile, maxval)];
218 rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
219 ptr += 4;
220 }
221 }
222 return 1;
223 }
224
225
226 #define RGB_READ_LOOP(read_op, alpha_set_op) { \
227 for (col = cinfo->image_width; col > 0; col--) { \
228 ptr[rindex] = read_op; \
229 ptr[gindex] = read_op; \
230 ptr[bindex] = read_op; \
231 alpha_set_op \
232 ptr += ps; \
233 } \
234 }
235
236 METHODDEF(JDIMENSION)
get_text_rgb_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)237 get_text_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
238 /* This version is for reading text-format PPM files with any maxval */
239 {
240 ppm_source_ptr source = (ppm_source_ptr)sinfo;
241 FILE *infile = source->pub.input_file;
242 register JSAMPROW ptr;
243 register JSAMPLE *rescale = source->rescale;
244 JDIMENSION col;
245 unsigned int maxval = source->maxval;
246 register int rindex = rgb_red[cinfo->in_color_space];
247 register int gindex = rgb_green[cinfo->in_color_space];
248 register int bindex = rgb_blue[cinfo->in_color_space];
249 register int aindex = alpha_index[cinfo->in_color_space];
250 register int ps = rgb_pixelsize[cinfo->in_color_space];
251
252 ptr = source->pub.buffer[0];
253 if (maxval == MAXJSAMPLE) {
254 if (aindex >= 0)
255 RGB_READ_LOOP((JSAMPLE)read_pbm_integer(cinfo, infile, maxval),
256 ptr[aindex] = 0xFF;)
257 else
258 RGB_READ_LOOP((JSAMPLE)read_pbm_integer(cinfo, infile, maxval), {})
259 } else {
260 if (aindex >= 0)
261 RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)],
262 ptr[aindex] = 0xFF;)
263 else
264 RGB_READ_LOOP(rescale[read_pbm_integer(cinfo, infile, maxval)], {})
265 }
266 return 1;
267 }
268
269
270 METHODDEF(JDIMENSION)
get_text_rgb_cmyk_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)271 get_text_rgb_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
272 /* This version is for reading text-format PPM files with any maxval and
273 converting to CMYK */
274 {
275 ppm_source_ptr source = (ppm_source_ptr)sinfo;
276 FILE *infile = source->pub.input_file;
277 register JSAMPROW ptr;
278 register JSAMPLE *rescale = source->rescale;
279 JDIMENSION col;
280 unsigned int maxval = source->maxval;
281
282 ptr = source->pub.buffer[0];
283 if (maxval == MAXJSAMPLE) {
284 for (col = cinfo->image_width; col > 0; col--) {
285 JSAMPLE r = (JSAMPLE)read_pbm_integer(cinfo, infile, maxval);
286 JSAMPLE g = (JSAMPLE)read_pbm_integer(cinfo, infile, maxval);
287 JSAMPLE b = (JSAMPLE)read_pbm_integer(cinfo, infile, maxval);
288 rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
289 ptr += 4;
290 }
291 } else {
292 for (col = cinfo->image_width; col > 0; col--) {
293 JSAMPLE r = rescale[read_pbm_integer(cinfo, infile, maxval)];
294 JSAMPLE g = rescale[read_pbm_integer(cinfo, infile, maxval)];
295 JSAMPLE b = rescale[read_pbm_integer(cinfo, infile, maxval)];
296 rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
297 ptr += 4;
298 }
299 }
300 return 1;
301 }
302
303
304 METHODDEF(JDIMENSION)
get_scaled_gray_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)305 get_scaled_gray_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
306 /* This version is for reading raw-byte-format PGM files with any maxval */
307 {
308 ppm_source_ptr source = (ppm_source_ptr)sinfo;
309 register JSAMPROW ptr;
310 register U_CHAR *bufferptr;
311 register JSAMPLE *rescale = source->rescale;
312 JDIMENSION col;
313
314 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
315 ERREXIT(cinfo, JERR_INPUT_EOF);
316 ptr = source->pub.buffer[0];
317 bufferptr = source->iobuffer;
318 for (col = cinfo->image_width; col > 0; col--) {
319 *ptr++ = rescale[UCH(*bufferptr++)];
320 }
321 return 1;
322 }
323
324
325 METHODDEF(JDIMENSION)
get_gray_rgb_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)326 get_gray_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
327 /* This version is for reading raw-byte-format PGM files with any maxval
328 and converting to extended RGB */
329 {
330 ppm_source_ptr source = (ppm_source_ptr)sinfo;
331 register JSAMPROW ptr;
332 register U_CHAR *bufferptr;
333 register JSAMPLE *rescale = source->rescale;
334 JDIMENSION col;
335 unsigned int maxval = source->maxval;
336 register int rindex = rgb_red[cinfo->in_color_space];
337 register int gindex = rgb_green[cinfo->in_color_space];
338 register int bindex = rgb_blue[cinfo->in_color_space];
339 register int aindex = alpha_index[cinfo->in_color_space];
340 register int ps = rgb_pixelsize[cinfo->in_color_space];
341
342 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
343 ERREXIT(cinfo, JERR_INPUT_EOF);
344 ptr = source->pub.buffer[0];
345 bufferptr = source->iobuffer;
346 if (maxval == MAXJSAMPLE) {
347 if (aindex >= 0)
348 GRAY_RGB_READ_LOOP(*bufferptr++, ptr[aindex] = 0xFF;)
349 else
350 GRAY_RGB_READ_LOOP(*bufferptr++, {})
351 } else {
352 if (aindex >= 0)
353 GRAY_RGB_READ_LOOP(rescale[UCH(*bufferptr++)], ptr[aindex] = 0xFF;)
354 else
355 GRAY_RGB_READ_LOOP(rescale[UCH(*bufferptr++)], {})
356 }
357 return 1;
358 }
359
360
361 METHODDEF(JDIMENSION)
get_gray_cmyk_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)362 get_gray_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
363 /* This version is for reading raw-byte-format PGM files with any maxval
364 and converting to CMYK */
365 {
366 ppm_source_ptr source = (ppm_source_ptr)sinfo;
367 register JSAMPROW ptr;
368 register U_CHAR *bufferptr;
369 register JSAMPLE *rescale = source->rescale;
370 JDIMENSION col;
371 unsigned int maxval = source->maxval;
372
373 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
374 ERREXIT(cinfo, JERR_INPUT_EOF);
375 ptr = source->pub.buffer[0];
376 bufferptr = source->iobuffer;
377 if (maxval == MAXJSAMPLE) {
378 for (col = cinfo->image_width; col > 0; col--) {
379 JSAMPLE gray = *bufferptr++;
380 rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
381 ptr += 4;
382 }
383 } else {
384 for (col = cinfo->image_width; col > 0; col--) {
385 JSAMPLE gray = rescale[UCH(*bufferptr++)];
386 rgb_to_cmyk(gray, gray, gray, ptr, ptr + 1, ptr + 2, ptr + 3);
387 ptr += 4;
388 }
389 }
390 return 1;
391 }
392
393
394 METHODDEF(JDIMENSION)
get_rgb_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)395 get_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
396 /* This version is for reading raw-byte-format PPM files with any maxval */
397 {
398 ppm_source_ptr source = (ppm_source_ptr)sinfo;
399 register JSAMPROW ptr;
400 register U_CHAR *bufferptr;
401 register JSAMPLE *rescale = source->rescale;
402 JDIMENSION col;
403 unsigned int maxval = source->maxval;
404 register int rindex = rgb_red[cinfo->in_color_space];
405 register int gindex = rgb_green[cinfo->in_color_space];
406 register int bindex = rgb_blue[cinfo->in_color_space];
407 register int aindex = alpha_index[cinfo->in_color_space];
408 register int ps = rgb_pixelsize[cinfo->in_color_space];
409
410 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
411 ERREXIT(cinfo, JERR_INPUT_EOF);
412 ptr = source->pub.buffer[0];
413 bufferptr = source->iobuffer;
414 if (maxval == MAXJSAMPLE) {
415 if (aindex >= 0)
416 RGB_READ_LOOP(*bufferptr++, ptr[aindex] = 0xFF;)
417 else
418 RGB_READ_LOOP(*bufferptr++, {})
419 } else {
420 if (aindex >= 0)
421 RGB_READ_LOOP(rescale[UCH(*bufferptr++)], ptr[aindex] = 0xFF;)
422 else
423 RGB_READ_LOOP(rescale[UCH(*bufferptr++)], {})
424 }
425 return 1;
426 }
427
428
429 METHODDEF(JDIMENSION)
get_rgb_cmyk_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)430 get_rgb_cmyk_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
431 /* This version is for reading raw-byte-format PPM files with any maxval and
432 converting to CMYK */
433 {
434 ppm_source_ptr source = (ppm_source_ptr)sinfo;
435 register JSAMPROW ptr;
436 register U_CHAR *bufferptr;
437 register JSAMPLE *rescale = source->rescale;
438 JDIMENSION col;
439 unsigned int maxval = source->maxval;
440
441 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
442 ERREXIT(cinfo, JERR_INPUT_EOF);
443 ptr = source->pub.buffer[0];
444 bufferptr = source->iobuffer;
445 if (maxval == MAXJSAMPLE) {
446 for (col = cinfo->image_width; col > 0; col--) {
447 JSAMPLE r = *bufferptr++;
448 JSAMPLE g = *bufferptr++;
449 JSAMPLE b = *bufferptr++;
450 rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
451 ptr += 4;
452 }
453 } else {
454 for (col = cinfo->image_width; col > 0; col--) {
455 JSAMPLE r = rescale[UCH(*bufferptr++)];
456 JSAMPLE g = rescale[UCH(*bufferptr++)];
457 JSAMPLE b = rescale[UCH(*bufferptr++)];
458 rgb_to_cmyk(r, g, b, ptr, ptr + 1, ptr + 2, ptr + 3);
459 ptr += 4;
460 }
461 }
462 return 1;
463 }
464
465
466 METHODDEF(JDIMENSION)
get_raw_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)467 get_raw_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
468 /* This version is for reading raw-byte-format files with maxval = MAXJSAMPLE.
469 * In this case we just read right into the JSAMPLE buffer!
470 * Note that same code works for PPM and PGM files.
471 */
472 {
473 ppm_source_ptr source = (ppm_source_ptr)sinfo;
474
475 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
476 ERREXIT(cinfo, JERR_INPUT_EOF);
477 return 1;
478 }
479
480
481 METHODDEF(JDIMENSION)
get_word_gray_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)482 get_word_gray_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
483 /* This version is for reading raw-word-format PGM files with any maxval */
484 {
485 ppm_source_ptr source = (ppm_source_ptr)sinfo;
486 register JSAMPROW ptr;
487 register U_CHAR *bufferptr;
488 register JSAMPLE *rescale = source->rescale;
489 JDIMENSION col;
490 unsigned int maxval = source->maxval;
491
492 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
493 ERREXIT(cinfo, JERR_INPUT_EOF);
494 ptr = source->pub.buffer[0];
495 bufferptr = source->iobuffer;
496 for (col = cinfo->image_width; col > 0; col--) {
497 register unsigned int temp;
498 temp = UCH(*bufferptr++) << 8;
499 temp |= UCH(*bufferptr++);
500 if (temp > maxval)
501 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
502 *ptr++ = rescale[temp];
503 }
504 return 1;
505 }
506
507
508 METHODDEF(JDIMENSION)
get_word_rgb_row(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)509 get_word_rgb_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
510 /* This version is for reading raw-word-format PPM files with any maxval */
511 {
512 ppm_source_ptr source = (ppm_source_ptr)sinfo;
513 register JSAMPROW ptr;
514 register U_CHAR *bufferptr;
515 register JSAMPLE *rescale = source->rescale;
516 JDIMENSION col;
517 unsigned int maxval = source->maxval;
518 register int rindex = rgb_red[cinfo->in_color_space];
519 register int gindex = rgb_green[cinfo->in_color_space];
520 register int bindex = rgb_blue[cinfo->in_color_space];
521 register int aindex = alpha_index[cinfo->in_color_space];
522 register int ps = rgb_pixelsize[cinfo->in_color_space];
523
524 if (!ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
525 ERREXIT(cinfo, JERR_INPUT_EOF);
526 ptr = source->pub.buffer[0];
527 bufferptr = source->iobuffer;
528 for (col = cinfo->image_width; col > 0; col--) {
529 register unsigned int temp;
530 temp = UCH(*bufferptr++) << 8;
531 temp |= UCH(*bufferptr++);
532 if (temp > maxval)
533 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
534 ptr[rindex] = rescale[temp];
535 temp = UCH(*bufferptr++) << 8;
536 temp |= UCH(*bufferptr++);
537 if (temp > maxval)
538 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
539 ptr[gindex] = rescale[temp];
540 temp = UCH(*bufferptr++) << 8;
541 temp |= UCH(*bufferptr++);
542 if (temp > maxval)
543 ERREXIT(cinfo, JERR_PPM_OUTOFRANGE);
544 ptr[bindex] = rescale[temp];
545 if (aindex >= 0)
546 ptr[aindex] = 0xFF;
547 ptr += ps;
548 }
549 return 1;
550 }
551
552
553 /*
554 * Read the file header; return image size and component count.
555 */
556
557 METHODDEF(void)
start_input_ppm(j_compress_ptr cinfo,cjpeg_source_ptr sinfo)558 start_input_ppm(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
559 {
560 ppm_source_ptr source = (ppm_source_ptr)sinfo;
561 int c;
562 unsigned int w, h, maxval;
563 boolean need_iobuffer, use_raw_buffer, need_rescale;
564
565 if (getc(source->pub.input_file) != 'P')
566 ERREXIT(cinfo, JERR_PPM_NOT);
567
568 c = getc(source->pub.input_file); /* subformat discriminator character */
569
570 /* detect unsupported variants (ie, PBM) before trying to read header */
571 switch (c) {
572 case '2': /* it's a text-format PGM file */
573 case '3': /* it's a text-format PPM file */
574 case '5': /* it's a raw-format PGM file */
575 case '6': /* it's a raw-format PPM file */
576 break;
577 default:
578 ERREXIT(cinfo, JERR_PPM_NOT);
579 break;
580 }
581
582 /* fetch the remaining header info */
583 w = read_pbm_integer(cinfo, source->pub.input_file, 65535);
584 h = read_pbm_integer(cinfo, source->pub.input_file, 65535);
585 maxval = read_pbm_integer(cinfo, source->pub.input_file, 65535);
586
587 if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
588 ERREXIT(cinfo, JERR_PPM_NOT);
589 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
590 if (sinfo->max_pixels && (unsigned long long)w * h > sinfo->max_pixels)
591 ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
592 #endif
593
594 cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */
595 cinfo->image_width = (JDIMENSION)w;
596 cinfo->image_height = (JDIMENSION)h;
597 source->maxval = maxval;
598
599 /* initialize flags to most common settings */
600 need_iobuffer = TRUE; /* do we need an I/O buffer? */
601 use_raw_buffer = FALSE; /* do we map input buffer onto I/O buffer? */
602 need_rescale = TRUE; /* do we need a rescale array? */
603
604 switch (c) {
605 case '2': /* it's a text-format PGM file */
606 if (cinfo->in_color_space == JCS_UNKNOWN ||
607 cinfo->in_color_space == JCS_RGB)
608 cinfo->in_color_space = JCS_GRAYSCALE;
609 TRACEMS2(cinfo, 1, JTRC_PGM_TEXT, w, h);
610 if (cinfo->in_color_space == JCS_GRAYSCALE)
611 source->pub.get_pixel_rows = get_text_gray_row;
612 else if (IsExtRGB(cinfo->in_color_space))
613 source->pub.get_pixel_rows = get_text_gray_rgb_row;
614 else if (cinfo->in_color_space == JCS_CMYK)
615 source->pub.get_pixel_rows = get_text_gray_cmyk_row;
616 else
617 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
618 need_iobuffer = FALSE;
619 break;
620
621 case '3': /* it's a text-format PPM file */
622 if (cinfo->in_color_space == JCS_UNKNOWN)
623 cinfo->in_color_space = JCS_EXT_RGB;
624 TRACEMS2(cinfo, 1, JTRC_PPM_TEXT, w, h);
625 if (IsExtRGB(cinfo->in_color_space))
626 source->pub.get_pixel_rows = get_text_rgb_row;
627 else if (cinfo->in_color_space == JCS_CMYK)
628 source->pub.get_pixel_rows = get_text_rgb_cmyk_row;
629 else
630 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
631 need_iobuffer = FALSE;
632 break;
633
634 case '5': /* it's a raw-format PGM file */
635 if (cinfo->in_color_space == JCS_UNKNOWN ||
636 cinfo->in_color_space == JCS_RGB)
637 cinfo->in_color_space = JCS_GRAYSCALE;
638 TRACEMS2(cinfo, 1, JTRC_PGM, w, h);
639 if (maxval > 255) {
640 if (cinfo->in_color_space == JCS_GRAYSCALE)
641 source->pub.get_pixel_rows = get_word_gray_row;
642 else
643 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
644 } else if (maxval == MAXJSAMPLE && sizeof(JSAMPLE) == sizeof(U_CHAR) &&
645 cinfo->in_color_space == JCS_GRAYSCALE) {
646 source->pub.get_pixel_rows = get_raw_row;
647 use_raw_buffer = TRUE;
648 need_rescale = FALSE;
649 } else {
650 if (cinfo->in_color_space == JCS_GRAYSCALE)
651 source->pub.get_pixel_rows = get_scaled_gray_row;
652 else if (IsExtRGB(cinfo->in_color_space))
653 source->pub.get_pixel_rows = get_gray_rgb_row;
654 else if (cinfo->in_color_space == JCS_CMYK)
655 source->pub.get_pixel_rows = get_gray_cmyk_row;
656 else
657 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
658 }
659 break;
660
661 case '6': /* it's a raw-format PPM file */
662 if (cinfo->in_color_space == JCS_UNKNOWN)
663 cinfo->in_color_space = JCS_EXT_RGB;
664 TRACEMS2(cinfo, 1, JTRC_PPM, w, h);
665 if (maxval > 255) {
666 if (IsExtRGB(cinfo->in_color_space))
667 source->pub.get_pixel_rows = get_word_rgb_row;
668 else
669 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
670 } else if (maxval == MAXJSAMPLE && sizeof(JSAMPLE) == sizeof(U_CHAR) &&
671 #if RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 3
672 (cinfo->in_color_space == JCS_EXT_RGB ||
673 cinfo->in_color_space == JCS_RGB)) {
674 #else
675 cinfo->in_color_space == JCS_EXT_RGB) {
676 #endif
677 source->pub.get_pixel_rows = get_raw_row;
678 use_raw_buffer = TRUE;
679 need_rescale = FALSE;
680 } else {
681 if (IsExtRGB(cinfo->in_color_space))
682 source->pub.get_pixel_rows = get_rgb_row;
683 else if (cinfo->in_color_space == JCS_CMYK)
684 source->pub.get_pixel_rows = get_rgb_cmyk_row;
685 else
686 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
687 }
688 break;
689 }
690
691 if (IsExtRGB(cinfo->in_color_space))
692 cinfo->input_components = rgb_pixelsize[cinfo->in_color_space];
693 else if (cinfo->in_color_space == JCS_GRAYSCALE)
694 cinfo->input_components = 1;
695 else if (cinfo->in_color_space == JCS_CMYK)
696 cinfo->input_components = 4;
697
698 /* Allocate space for I/O buffer: 1 or 3 bytes or words/pixel. */
699 if (need_iobuffer) {
700 if (c == '6')
701 source->buffer_width = (size_t)w * 3 *
702 ((maxval <= 255) ? sizeof(U_CHAR) : (2 * sizeof(U_CHAR)));
703 else
704 source->buffer_width = (size_t)w *
705 ((maxval <= 255) ? sizeof(U_CHAR) : (2 * sizeof(U_CHAR)));
706 source->iobuffer = (U_CHAR *)
707 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
708 source->buffer_width);
709 }
710
711 /* Create compressor input buffer. */
712 if (use_raw_buffer) {
713 /* For unscaled raw-input case, we can just map it onto the I/O buffer. */
714 /* Synthesize a JSAMPARRAY pointer structure */
715 source->pixrow = (JSAMPROW)source->iobuffer;
716 source->pub.buffer = &source->pixrow;
717 source->pub.buffer_height = 1;
718 } else {
719 /* Need to translate anyway, so make a separate sample buffer. */
720 source->pub.buffer = (*cinfo->mem->alloc_sarray)
721 ((j_common_ptr)cinfo, JPOOL_IMAGE,
722 (JDIMENSION)w * cinfo->input_components, (JDIMENSION)1);
723 source->pub.buffer_height = 1;
724 }
725
726 /* Compute the rescaling array if required. */
727 if (need_rescale) {
728 long val, half_maxval;
729
730 /* On 16-bit-int machines we have to be careful of maxval = 65535 */
731 source->rescale = (JSAMPLE *)
732 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
733 (size_t)(((long)MAX(maxval, 255) + 1L) *
734 sizeof(JSAMPLE)));
735 memset(source->rescale, 0, (size_t)(((long)MAX(maxval, 255) + 1L) *
736 sizeof(JSAMPLE)));
737 half_maxval = maxval / 2;
738 for (val = 0; val <= (long)maxval; val++) {
739 /* The multiplication here must be done in 32 bits to avoid overflow */
740 source->rescale[val] = (JSAMPLE)((val * MAXJSAMPLE + half_maxval) /
741 maxval);
742 }
743 }
744 }
745
746
747 /*
748 * Finish up at the end of the file.
749 */
750
751 METHODDEF(void)
752 finish_input_ppm(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
753 {
754 /* no work */
755 }
756
757
758 /*
759 * The module selection routine for PPM format input.
760 */
761
762 GLOBAL(cjpeg_source_ptr)
763 jinit_read_ppm(j_compress_ptr cinfo)
764 {
765 ppm_source_ptr source;
766
767 /* Create module interface object */
768 source = (ppm_source_ptr)
769 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
770 sizeof(ppm_source_struct));
771 /* Fill in method ptrs, except get_pixel_rows which start_input sets */
772 source->pub.start_input = start_input_ppm;
773 source->pub.finish_input = finish_input_ppm;
774 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
775 source->pub.max_pixels = 0;
776 #endif
777
778 return (cjpeg_source_ptr)source;
779 }
780
781 #endif /* PPM_SUPPORTED */
782