/src/libjpeg-turbo.main/wrppm.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * wrppm.c |
3 | | * |
4 | | * This file was part of the Independent JPEG Group's software: |
5 | | * Copyright (C) 1991-1996, Thomas G. Lane. |
6 | | * Modified 2009 by Guido Vollbeding. |
7 | | * libjpeg-turbo Modifications: |
8 | | * Copyright (C) 2017, 2019-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 write output 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 output to |
19 | | * an ordinary stdio stream. |
20 | | */ |
21 | | |
22 | | #include "cmyk.h" |
23 | | #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ |
24 | | |
25 | | #ifdef PPM_SUPPORTED |
26 | | |
27 | | |
28 | | /* |
29 | | * For 12-bit JPEG data, we either downscale the values to 8 bits |
30 | | * (to write standard byte-per-sample PPM/PGM files), or output |
31 | | * nonstandard word-per-sample PPM/PGM files. Downscaling is done |
32 | | * if PPM_NORAWWORD is defined (this can be done in the Makefile |
33 | | * or in jconfig.h). |
34 | | * (When the core library supports data precision reduction, a cleaner |
35 | | * implementation will be to ask for that instead.) |
36 | | */ |
37 | | |
38 | | #if BITS_IN_JSAMPLE == 8 |
39 | 0 | #define PUTPPMSAMPLE(ptr, v) *ptr++ = (char)(v) |
40 | 0 | #define BYTESPERSAMPLE 1 |
41 | 0 | #define PPM_MAXVAL 255 |
42 | | #else |
43 | | #ifdef PPM_NORAWWORD |
44 | | #define PUTPPMSAMPLE(ptr, v) *ptr++ = (char)((v) >> (BITS_IN_JSAMPLE - 8)) |
45 | | #define BYTESPERSAMPLE 1 |
46 | | #define PPM_MAXVAL 255 |
47 | | #else |
48 | | /* The word-per-sample format always puts the MSB first. */ |
49 | | #define PUTPPMSAMPLE(ptr, v) { \ |
50 | | register int val_ = v; \ |
51 | | *ptr++ = (char)((val_ >> 8) & 0xFF); \ |
52 | | *ptr++ = (char)(val_ & 0xFF); \ |
53 | | } |
54 | | #define BYTESPERSAMPLE 2 |
55 | | #define PPM_MAXVAL ((1 << BITS_IN_JSAMPLE) - 1) |
56 | | #endif |
57 | | #endif |
58 | | |
59 | | |
60 | | /* |
61 | | * When JSAMPLE is the same size as char, we can just fwrite() the |
62 | | * decompressed data to the PPM or PGM file. |
63 | | */ |
64 | | |
65 | | |
66 | | /* Private version of data destination object */ |
67 | | |
68 | | typedef struct { |
69 | | struct djpeg_dest_struct pub; /* public fields */ |
70 | | |
71 | | /* Usually these two pointers point to the same place: */ |
72 | | char *iobuffer; /* fwrite's I/O buffer */ |
73 | | JSAMPROW pixrow; /* decompressor output buffer */ |
74 | | size_t buffer_width; /* width of I/O buffer */ |
75 | | JDIMENSION samples_per_row; /* JSAMPLEs per output row */ |
76 | | } ppm_dest_struct; |
77 | | |
78 | | typedef ppm_dest_struct *ppm_dest_ptr; |
79 | | |
80 | | |
81 | | /* |
82 | | * Write some pixel data. |
83 | | * In this module rows_supplied will always be 1. |
84 | | * |
85 | | * put_pixel_rows handles the "normal" 8-bit case where the decompressor |
86 | | * output buffer is physically the same as the fwrite buffer. |
87 | | */ |
88 | | |
89 | | METHODDEF(void) |
90 | | put_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, |
91 | | JDIMENSION rows_supplied) |
92 | 0 | { |
93 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
94 | |
|
95 | 0 | fwrite(dest->iobuffer, 1, dest->buffer_width, dest->pub.output_file); |
96 | 0 | } |
97 | | |
98 | | |
99 | | /* |
100 | | * This code is used when we have to copy the data and apply a pixel |
101 | | * format translation. Typically this only happens in 12-bit mode. |
102 | | */ |
103 | | |
104 | | METHODDEF(void) |
105 | | copy_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, |
106 | | JDIMENSION rows_supplied) |
107 | 0 | { |
108 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
109 | 0 | register char *bufferptr; |
110 | 0 | register JSAMPROW ptr; |
111 | | #if BITS_IN_JSAMPLE != 8 |
112 | | register JDIMENSION col; |
113 | | #endif |
114 | |
|
115 | 0 | ptr = dest->pub.buffer[0]; |
116 | 0 | bufferptr = dest->iobuffer; |
117 | 0 | #if BITS_IN_JSAMPLE == 8 |
118 | 0 | memcpy(bufferptr, ptr, dest->samples_per_row); |
119 | | #else |
120 | | for (col = dest->samples_per_row; col > 0; col--) { |
121 | | PUTPPMSAMPLE(bufferptr, *ptr++); |
122 | | } |
123 | | #endif |
124 | 0 | fwrite(dest->iobuffer, 1, dest->buffer_width, dest->pub.output_file); |
125 | 0 | } |
126 | | |
127 | | |
128 | | /* |
129 | | * Convert extended RGB to RGB. |
130 | | */ |
131 | | |
132 | | METHODDEF(void) |
133 | | put_rgb(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) |
134 | 0 | { |
135 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
136 | 0 | register char *bufferptr; |
137 | 0 | register JSAMPROW ptr; |
138 | 0 | register JDIMENSION col; |
139 | 0 | register int rindex = rgb_red[cinfo->out_color_space]; |
140 | 0 | register int gindex = rgb_green[cinfo->out_color_space]; |
141 | 0 | register int bindex = rgb_blue[cinfo->out_color_space]; |
142 | 0 | register int ps = rgb_pixelsize[cinfo->out_color_space]; |
143 | |
|
144 | 0 | ptr = dest->pub.buffer[0]; |
145 | 0 | bufferptr = dest->iobuffer; |
146 | 0 | for (col = cinfo->output_width; col > 0; col--) { |
147 | 0 | PUTPPMSAMPLE(bufferptr, ptr[rindex]); |
148 | 0 | PUTPPMSAMPLE(bufferptr, ptr[gindex]); |
149 | 0 | PUTPPMSAMPLE(bufferptr, ptr[bindex]); |
150 | 0 | ptr += ps; |
151 | 0 | } |
152 | 0 | fwrite(dest->iobuffer, 1, dest->buffer_width, dest->pub.output_file); |
153 | 0 | } |
154 | | |
155 | | |
156 | | /* |
157 | | * Convert CMYK to RGB. |
158 | | */ |
159 | | |
160 | | METHODDEF(void) |
161 | | put_cmyk(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, |
162 | | JDIMENSION rows_supplied) |
163 | 0 | { |
164 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
165 | 0 | register char *bufferptr; |
166 | 0 | register JSAMPROW ptr; |
167 | 0 | register JDIMENSION col; |
168 | |
|
169 | 0 | ptr = dest->pub.buffer[0]; |
170 | 0 | bufferptr = dest->iobuffer; |
171 | 0 | for (col = cinfo->output_width; col > 0; col--) { |
172 | 0 | JSAMPLE r, g, b, c = *ptr++, m = *ptr++, y = *ptr++, k = *ptr++; |
173 | 0 | cmyk_to_rgb(c, m, y, k, &r, &g, &b); |
174 | 0 | PUTPPMSAMPLE(bufferptr, r); |
175 | 0 | PUTPPMSAMPLE(bufferptr, g); |
176 | 0 | PUTPPMSAMPLE(bufferptr, b); |
177 | 0 | } |
178 | 0 | fwrite(dest->iobuffer, 1, dest->buffer_width, dest->pub.output_file); |
179 | 0 | } |
180 | | |
181 | | |
182 | | /* |
183 | | * Write some pixel data when color quantization is in effect. |
184 | | * We have to demap the color index values to straight data. |
185 | | */ |
186 | | |
187 | | METHODDEF(void) |
188 | | put_demapped_rgb(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, |
189 | | JDIMENSION rows_supplied) |
190 | 0 | { |
191 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
192 | 0 | register char *bufferptr; |
193 | 0 | register int pixval; |
194 | 0 | register JSAMPROW ptr; |
195 | 0 | register JSAMPROW color_map0 = cinfo->colormap[0]; |
196 | 0 | register JSAMPROW color_map1 = cinfo->colormap[1]; |
197 | 0 | register JSAMPROW color_map2 = cinfo->colormap[2]; |
198 | 0 | register JDIMENSION col; |
199 | |
|
200 | 0 | ptr = dest->pub.buffer[0]; |
201 | 0 | bufferptr = dest->iobuffer; |
202 | 0 | for (col = cinfo->output_width; col > 0; col--) { |
203 | 0 | pixval = *ptr++; |
204 | 0 | PUTPPMSAMPLE(bufferptr, color_map0[pixval]); |
205 | 0 | PUTPPMSAMPLE(bufferptr, color_map1[pixval]); |
206 | 0 | PUTPPMSAMPLE(bufferptr, color_map2[pixval]); |
207 | 0 | } |
208 | 0 | fwrite(dest->iobuffer, 1, dest->buffer_width, dest->pub.output_file); |
209 | 0 | } |
210 | | |
211 | | |
212 | | METHODDEF(void) |
213 | | put_demapped_gray(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, |
214 | | JDIMENSION rows_supplied) |
215 | 0 | { |
216 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
217 | 0 | register char *bufferptr; |
218 | 0 | register JSAMPROW ptr; |
219 | 0 | register JSAMPROW color_map = cinfo->colormap[0]; |
220 | 0 | register JDIMENSION col; |
221 | |
|
222 | 0 | ptr = dest->pub.buffer[0]; |
223 | 0 | bufferptr = dest->iobuffer; |
224 | 0 | for (col = cinfo->output_width; col > 0; col--) { |
225 | 0 | PUTPPMSAMPLE(bufferptr, color_map[*ptr++]); |
226 | 0 | } |
227 | 0 | fwrite(dest->iobuffer, 1, dest->buffer_width, dest->pub.output_file); |
228 | 0 | } |
229 | | |
230 | | |
231 | | /* |
232 | | * Startup: write the file header. |
233 | | */ |
234 | | |
235 | | METHODDEF(void) |
236 | | start_output_ppm(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) |
237 | 0 | { |
238 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
239 | | |
240 | | /* Emit file header */ |
241 | 0 | switch (cinfo->out_color_space) { |
242 | 0 | case JCS_GRAYSCALE: |
243 | | /* emit header for raw PGM format */ |
244 | 0 | fprintf(dest->pub.output_file, "P5\n%ld %ld\n%d\n", |
245 | 0 | (long)cinfo->output_width, (long)cinfo->output_height, PPM_MAXVAL); |
246 | 0 | break; |
247 | 0 | case JCS_RGB: |
248 | 0 | case JCS_EXT_RGB: |
249 | 0 | case JCS_EXT_RGBX: |
250 | 0 | case JCS_EXT_BGR: |
251 | 0 | case JCS_EXT_BGRX: |
252 | 0 | case JCS_EXT_XBGR: |
253 | 0 | case JCS_EXT_XRGB: |
254 | 0 | case JCS_EXT_RGBA: |
255 | 0 | case JCS_EXT_BGRA: |
256 | 0 | case JCS_EXT_ABGR: |
257 | 0 | case JCS_EXT_ARGB: |
258 | 0 | case JCS_CMYK: |
259 | 0 | if (!IsExtRGB(cinfo->out_color_space) && cinfo->quantize_colors) |
260 | 0 | ERREXIT(cinfo, JERR_PPM_COLORSPACE); |
261 | | /* emit header for raw PPM format */ |
262 | 0 | fprintf(dest->pub.output_file, "P6\n%ld %ld\n%d\n", |
263 | 0 | (long)cinfo->output_width, (long)cinfo->output_height, PPM_MAXVAL); |
264 | 0 | break; |
265 | 0 | default: |
266 | 0 | ERREXIT(cinfo, JERR_PPM_COLORSPACE); |
267 | 0 | } |
268 | 0 | } |
269 | | |
270 | | |
271 | | /* |
272 | | * Finish up at the end of the file. |
273 | | */ |
274 | | |
275 | | METHODDEF(void) |
276 | | finish_output_ppm(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) |
277 | 0 | { |
278 | | /* Make sure we wrote the output file OK */ |
279 | 0 | fflush(dinfo->output_file); |
280 | 0 | if (ferror(dinfo->output_file)) |
281 | 0 | ERREXIT(cinfo, JERR_FILE_WRITE); |
282 | 0 | } |
283 | | |
284 | | |
285 | | /* |
286 | | * Re-calculate buffer dimensions based on output dimensions. |
287 | | */ |
288 | | |
289 | | METHODDEF(void) |
290 | | calc_buffer_dimensions_ppm(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) |
291 | 0 | { |
292 | 0 | ppm_dest_ptr dest = (ppm_dest_ptr)dinfo; |
293 | |
|
294 | 0 | if (cinfo->out_color_space == JCS_GRAYSCALE) |
295 | 0 | dest->samples_per_row = cinfo->output_width * cinfo->out_color_components; |
296 | 0 | else |
297 | 0 | dest->samples_per_row = cinfo->output_width * 3; |
298 | 0 | dest->buffer_width = dest->samples_per_row * (BYTESPERSAMPLE * sizeof(char)); |
299 | 0 | } |
300 | | |
301 | | |
302 | | /* |
303 | | * The module selection routine for PPM format output. |
304 | | */ |
305 | | |
306 | | GLOBAL(djpeg_dest_ptr) |
307 | | jinit_write_ppm(j_decompress_ptr cinfo) |
308 | 0 | { |
309 | 0 | ppm_dest_ptr dest; |
310 | | |
311 | | /* Create module interface object, fill in method pointers */ |
312 | 0 | dest = (ppm_dest_ptr) |
313 | 0 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
314 | 0 | sizeof(ppm_dest_struct)); |
315 | 0 | dest->pub.start_output = start_output_ppm; |
316 | 0 | dest->pub.finish_output = finish_output_ppm; |
317 | 0 | dest->pub.calc_buffer_dimensions = calc_buffer_dimensions_ppm; |
318 | | |
319 | | /* Calculate output image dimensions so we can allocate space */ |
320 | 0 | jpeg_calc_output_dimensions(cinfo); |
321 | | |
322 | | /* Create physical I/O buffer */ |
323 | 0 | dest->pub.calc_buffer_dimensions(cinfo, (djpeg_dest_ptr)dest); |
324 | 0 | dest->iobuffer = (char *)(*cinfo->mem->alloc_small) |
325 | 0 | ((j_common_ptr)cinfo, JPOOL_IMAGE, dest->buffer_width); |
326 | |
|
327 | 0 | if (cinfo->quantize_colors || BITS_IN_JSAMPLE != 8 || |
328 | 0 | sizeof(JSAMPLE) != sizeof(char) || |
329 | 0 | #if RGB_RED == 0 && RGB_GREEN == 1 && RGB_BLUE == 2 && RGB_PIXELSIZE == 3 |
330 | 0 | (cinfo->out_color_space != JCS_EXT_RGB && |
331 | 0 | cinfo->out_color_space != JCS_RGB)) { |
332 | | #else |
333 | | cinfo->out_color_space != JCS_EXT_RGB) { |
334 | | #endif |
335 | | /* When quantizing, we need an output buffer for colormap indexes |
336 | | * that's separate from the physical I/O buffer. We also need a |
337 | | * separate buffer if pixel format translation must take place. |
338 | | */ |
339 | 0 | dest->pub.buffer = (*cinfo->mem->alloc_sarray) |
340 | 0 | ((j_common_ptr)cinfo, JPOOL_IMAGE, |
341 | 0 | cinfo->output_width * cinfo->output_components, (JDIMENSION)1); |
342 | 0 | dest->pub.buffer_height = 1; |
343 | 0 | if (!cinfo->quantize_colors) { |
344 | 0 | if (IsExtRGB(cinfo->out_color_space)) |
345 | 0 | dest->pub.put_pixel_rows = put_rgb; |
346 | 0 | else if (cinfo->out_color_space == JCS_CMYK) |
347 | 0 | dest->pub.put_pixel_rows = put_cmyk; |
348 | 0 | else |
349 | 0 | dest->pub.put_pixel_rows = copy_pixel_rows; |
350 | 0 | } else if (cinfo->out_color_space == JCS_GRAYSCALE) |
351 | 0 | dest->pub.put_pixel_rows = put_demapped_gray; |
352 | 0 | else |
353 | 0 | dest->pub.put_pixel_rows = put_demapped_rgb; |
354 | 0 | } else { |
355 | | /* We will fwrite() directly from decompressor output buffer. */ |
356 | | /* Synthesize a JSAMPARRAY pointer structure */ |
357 | 0 | dest->pixrow = (JSAMPROW)dest->iobuffer; |
358 | 0 | dest->pub.buffer = &dest->pixrow; |
359 | 0 | dest->pub.buffer_height = 1; |
360 | 0 | dest->pub.put_pixel_rows = put_pixel_rows; |
361 | 0 | } |
362 | |
|
363 | 0 | return (djpeg_dest_ptr)dest; |
364 | 0 | } |
365 | | |
366 | | #endif /* PPM_SUPPORTED */ |