4 * This file was part of the Independent JPEG Group's software:
5 * Copyright (C) 1991-1996, Thomas G. Lane.
6 * libjpeg-turbo Modifications:
7 * Copyright (C) 2017, 2019, D. R. Commander.
8 * For conditions of distribution and use, see the accompanying README.ijg
11 * This file contains routines to write output images in Targa format.
13 * These routines may need modification for non-Unix environments or
14 * specialized applications. As they stand, they assume output to
15 * an ordinary stdio stream.
17 * Based on code contributed by Lee Daniel Crocker.
20 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
22 #ifdef TARGA_SUPPORTED
26 * To support 12-bit JPEG data, we'd have to scale output down to 8 bits.
27 * This is not yet implemented.
30 #if BITS_IN_JSAMPLE != 8
31 Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
35 /* Private version of data destination object */
38 struct djpeg_dest_struct pub; /* public fields */
40 char *iobuffer; /* physical I/O buffer */
41 JDIMENSION buffer_width; /* width of one row */
44 typedef tga_dest_struct *tga_dest_ptr;
48 write_header(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, int num_colors)
49 /* Create and write a Targa header */
53 /* Set unused fields of header to 0 */
54 MEMZERO(targaheader, sizeof(targaheader));
57 targaheader[1] = 1; /* color map type 1 */
58 targaheader[5] = (char)(num_colors & 0xFF);
59 targaheader[6] = (char)(num_colors >> 8);
60 targaheader[7] = 24; /* 24 bits per cmap entry */
63 targaheader[12] = (char)(cinfo->output_width & 0xFF);
64 targaheader[13] = (char)(cinfo->output_width >> 8);
65 targaheader[14] = (char)(cinfo->output_height & 0xFF);
66 targaheader[15] = (char)(cinfo->output_height >> 8);
67 targaheader[17] = 0x20; /* Top-down, non-interlaced */
69 if (cinfo->out_color_space == JCS_GRAYSCALE) {
70 targaheader[2] = 3; /* image type = uncompressed grayscale */
71 targaheader[16] = 8; /* bits per pixel */
72 } else { /* must be RGB */
74 targaheader[2] = 1; /* image type = colormapped RGB */
77 targaheader[2] = 2; /* image type = uncompressed RGB */
82 if (JFWRITE(dinfo->output_file, targaheader, 18) != (size_t)18)
83 ERREXIT(cinfo, JERR_FILE_WRITE);
88 * Write some pixel data.
89 * In this module rows_supplied will always be 1.
93 put_pixel_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
94 JDIMENSION rows_supplied)
95 /* used for unquantized full-color output */
97 tga_dest_ptr dest = (tga_dest_ptr)dinfo;
98 register JSAMPROW inptr;
99 register char *outptr;
100 register JDIMENSION col;
102 inptr = dest->pub.buffer[0];
103 outptr = dest->iobuffer;
104 for (col = cinfo->output_width; col > 0; col--) {
105 outptr[0] = inptr[2]; /* RGB to BGR order */
106 outptr[1] = inptr[1];
107 outptr[2] = inptr[0];
108 inptr += 3, outptr += 3;
110 (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
114 put_gray_rows(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
115 JDIMENSION rows_supplied)
116 /* used for grayscale OR quantized color output */
118 tga_dest_ptr dest = (tga_dest_ptr)dinfo;
119 register JSAMPROW inptr;
120 register char *outptr;
122 inptr = dest->pub.buffer[0];
123 outptr = dest->iobuffer;
124 MEMCOPY(outptr, inptr, cinfo->output_width);
125 (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
130 * Write some demapped pixel data when color quantization is in effect.
131 * For Targa, this is only applied to grayscale data.
135 put_demapped_gray(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
136 JDIMENSION rows_supplied)
138 tga_dest_ptr dest = (tga_dest_ptr)dinfo;
139 register JSAMPROW inptr;
140 register char *outptr;
141 register JSAMPROW color_map0 = cinfo->colormap[0];
142 register JDIMENSION col;
144 inptr = dest->pub.buffer[0];
145 outptr = dest->iobuffer;
146 for (col = cinfo->output_width; col > 0; col--) {
147 *outptr++ = color_map0[*inptr++];
149 (void)JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
154 * Startup: write the file header.
158 start_output_tga(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
160 tga_dest_ptr dest = (tga_dest_ptr)dinfo;
164 if (cinfo->out_color_space == JCS_GRAYSCALE) {
165 /* Targa doesn't have a mapped grayscale format, so we will */
166 /* demap quantized gray output. Never emit a colormap. */
167 write_header(cinfo, dinfo, 0);
168 if (cinfo->quantize_colors)
169 dest->pub.put_pixel_rows = put_demapped_gray;
171 dest->pub.put_pixel_rows = put_gray_rows;
172 } else if (cinfo->out_color_space == JCS_RGB) {
173 if (cinfo->quantize_colors) {
174 /* We only support 8-bit colormap indexes, so only 256 colors */
175 num_colors = cinfo->actual_number_of_colors;
176 if (num_colors > 256)
177 ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, num_colors);
178 write_header(cinfo, dinfo, num_colors);
179 /* Write the colormap. Note Targa uses BGR byte order */
180 outfile = dest->pub.output_file;
181 for (i = 0; i < num_colors; i++) {
182 putc(cinfo->colormap[2][i], outfile);
183 putc(cinfo->colormap[1][i], outfile);
184 putc(cinfo->colormap[0][i], outfile);
186 dest->pub.put_pixel_rows = put_gray_rows;
188 write_header(cinfo, dinfo, 0);
189 dest->pub.put_pixel_rows = put_pixel_rows;
192 ERREXIT(cinfo, JERR_TGA_COLORSPACE);
198 * Finish up at the end of the file.
202 finish_output_tga(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
204 /* Make sure we wrote the output file OK */
205 fflush(dinfo->output_file);
206 if (ferror(dinfo->output_file))
207 ERREXIT(cinfo, JERR_FILE_WRITE);
212 * Re-calculate buffer dimensions based on output dimensions.
216 calc_buffer_dimensions_tga(j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
218 tga_dest_ptr dest = (tga_dest_ptr)dinfo;
220 dest->buffer_width = cinfo->output_width * cinfo->output_components;
225 * The module selection routine for Targa format output.
228 GLOBAL(djpeg_dest_ptr)
229 jinit_write_targa(j_decompress_ptr cinfo)
233 /* Create module interface object, fill in method pointers */
234 dest = (tga_dest_ptr)
235 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
236 sizeof(tga_dest_struct));
237 dest->pub.start_output = start_output_tga;
238 dest->pub.finish_output = finish_output_tga;
239 dest->pub.calc_buffer_dimensions = calc_buffer_dimensions_tga;
241 /* Calculate output image dimensions so we can allocate space */
242 jpeg_calc_output_dimensions(cinfo);
244 /* Create I/O buffer. */
245 dest->pub.calc_buffer_dimensions(cinfo, (djpeg_dest_ptr)dest);
246 dest->iobuffer = (char *)
247 (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
248 (size_t)(dest->buffer_width * sizeof(char)));
250 /* Create decompressor output buffer. */
251 dest->pub.buffer = (*cinfo->mem->alloc_sarray)
252 ((j_common_ptr)cinfo, JPOOL_IMAGE, dest->buffer_width, (JDIMENSION)1);
253 dest->pub.buffer_height = 1;
255 return (djpeg_dest_ptr)dest;
258 #endif /* TARGA_SUPPORTED */