xref: /PHP-7.4/ext/gd/libgd/gd_tga.c (revision 81fd1135)
1 /**
2  * File: TGA Input
3  *
4  * Read TGA images.
5  */
6 
7 #ifdef HAVE_CONFIG_H
8 #include "config.h"
9 #endif /* HAVE_CONFIG_H */
10 
11 #include <stdio.h>
12 #include <stddef.h>
13 #include <stdlib.h>
14 #include <string.h>
15 
16 #include "gd_tga.h"
17 #include "gd.h"
18 #include "gd_errors.h"
19 #include "gdhelpers.h"
20 
21 /*
22 	Function: gdImageCreateFromTga
23 
24 	Creates a gdImage from a TGA file
25 
26 	Parameters:
27 
28 		infile - Pointer to TGA binary file
29  */
gdImageCreateFromTga(FILE * fp)30 gdImagePtr gdImageCreateFromTga(FILE *fp)
31 {
32 	gdImagePtr image;
33 	gdIOCtx* in = gdNewFileCtx(fp);
34 	if (in == NULL) return NULL;
35 	image = gdImageCreateFromTgaCtx(in);
36 	in->gd_free( in );
37 	return image;
38 }
39 
40 /*
41 	Function: gdImageCreateFromTgaPtr
42 */
gdImageCreateFromTgaPtr(int size,void * data)43 gdImagePtr gdImageCreateFromTgaPtr(int size, void *data)
44 {
45 	gdImagePtr im;
46 	gdIOCtx *in = gdNewDynamicCtxEx (size, data, 0);
47 	if (in == NULL) return NULL;
48 	im = gdImageCreateFromTgaCtx(in);
49 	in->gd_free(in);
50 	return im;
51 }
52 
53 
54 /*
55 	Function: gdImageCreateFromTgaCtx
56 
57 	Creates a gdImage from a gdIOCtx referencing a TGA binary file.
58 
59 	Parameters:
60 		ctx - Pointer to a gdIOCtx structure
61  */
gdImageCreateFromTgaCtx(gdIOCtx * ctx)62 gdImagePtr gdImageCreateFromTgaCtx(gdIOCtx* ctx)
63 {
64 	int bitmap_caret = 0;
65 	oTga *tga = NULL;
66 	/*	int pixel_block_size = 0;
67 		int image_block_size = 0; */
68 	volatile gdImagePtr image = NULL;
69 	int x = 0;
70 	int y = 0;
71 
72 	tga = (oTga *) gdMalloc(sizeof(oTga));
73 	if (!tga) {
74 		return NULL;
75 	}
76 
77 	tga->bitmap = NULL;
78 	tga->ident = NULL;
79 
80 	if (read_header_tga(ctx, tga) < 0) {
81 		free_tga(tga);
82 		return NULL;
83 	}
84 
85 	/*TODO: Will this be used?
86 		pixel_block_size = tga->bits / 8;
87 		image_block_size = (tga->width * tga->height) * pixel_block_size;
88 	*/
89 
90 	if (read_image_tga(ctx, tga) < 0) {
91 		free_tga(tga);
92 		return NULL;
93 	}
94 
95 	image = gdImageCreateTrueColor((int)tga->width, (int)tga->height );
96 
97 	if (image == 0) {
98 		free_tga( tga );
99 		return NULL;
100 	}
101 
102 	/*!	\brief Populate GD image object
103 	 *  Copy the pixel data from our tga bitmap buffer into the GD image
104 	 *  Disable blending and save the alpha channel per default
105 	 */
106 	if (tga->alphabits) {
107 		gdImageAlphaBlending(image, 0);
108 		gdImageSaveAlpha(image, 1);
109 	}
110 
111 	/* TODO: use alphabits as soon as we support 24bit and other alpha bps (ie != 8bits) */
112 	for (y = 0; y < tga->height; y++) {
113 		register int *tpix = image->tpixels[y];
114 		for ( x = 0; x < tga->width; x++, tpix++) {
115 			if (tga->bits == TGA_BPP_24) {
116 				*tpix = gdTrueColor(tga->bitmap[bitmap_caret + 2], tga->bitmap[bitmap_caret + 1], tga->bitmap[bitmap_caret]);
117 				bitmap_caret += 3;
118 			} else if (tga->bits == TGA_BPP_32 && tga->alphabits) {
119 				register int a = tga->bitmap[bitmap_caret + 3];
120 
121 				*tpix = gdTrueColorAlpha(tga->bitmap[bitmap_caret + 2], tga->bitmap[bitmap_caret + 1], tga->bitmap[bitmap_caret], gdAlphaMax - (a >> 1));
122 				bitmap_caret += 4;
123 			}
124 		}
125 	}
126 
127 	if (tga->flipv && tga->fliph) {
128 		gdImageFlipBoth(image);
129 	} else if (tga->flipv) {
130 		gdImageFlipVertical(image);
131 	} else if (tga->fliph) {
132 		gdImageFlipHorizontal(image);
133 	}
134 
135 	free_tga(tga);
136 
137 	return image;
138 }
139 
140 /*!	\brief Reads a TGA header.
141  *	Reads the header block from a binary TGA file populating the referenced TGA structure.
142  *	\param ctx Pointer to TGA binary file
143  *	\param tga Pointer to TGA structure
144  *	\return int 1 on sucess, -1 on failure
145  */
read_header_tga(gdIOCtx * ctx,oTga * tga)146 int read_header_tga(gdIOCtx *ctx, oTga *tga)
147 {
148 
149 	unsigned char header[18];
150 
151 	if (gdGetBuf(header, sizeof(header), ctx) < 18) {
152 		gd_error("fail to read header");
153 		return -1;
154 	}
155 
156 	tga->identsize = header[0];
157 	tga->colormaptype = header[1];
158 	tga->imagetype = header[2];
159 	tga->colormapstart = header[3] + (header[4] << 8);
160 	tga->colormaplength = header[5] + (header[6] << 8);
161 	tga->colormapbits = header[7];
162 	tga->xstart = header[8] + (header[9] << 8);
163 	tga->ystart = header[10] + (header[11] << 8);
164 	tga->width = header[12] + (header[13] << 8);
165 	tga->height = header[14] + (header[15] << 8);
166 	tga->bits = header[16];
167 	tga->alphabits = header[17] & 0x0f;
168 	tga->fliph = (header[17] & 0x10) ? 1 : 0;
169 	tga->flipv = (header[17] & 0x20) ? 0 : 1;
170 
171 #if DEBUG
172 	printf("format bps: %i\n", tga->bits);
173 	printf("flip h/v: %i / %i\n", tga->fliph, tga->flipv);
174 	printf("alpha: %i\n", tga->alphabits);
175 	printf("wxh: %i %i\n", tga->width, tga->height);
176 #endif
177 
178 	if (!((tga->bits == TGA_BPP_24 && tga->alphabits == 0)
179 		|| (tga->bits == TGA_BPP_32 && tga->alphabits == 8)))
180 	{
181 		gd_error_ex(GD_WARNING, "gd-tga: %u bits per pixel with %u alpha bits not supported\n",
182 			tga->bits, tga->alphabits);
183 		return -1;
184 	}
185 
186 	tga->ident = NULL;
187 
188 	if (tga->identsize > 0) {
189 		tga->ident = (char *) gdMalloc(tga->identsize * sizeof(char));
190 		if(tga->ident == NULL) {
191 			return -1;
192 		}
193 
194 		gdGetBuf(tga->ident, tga->identsize, ctx);
195 	}
196 
197 	return 1;
198 }
199 
200 /*!	\brief Reads a TGA image data into buffer.
201  *	Reads the image data block from a binary TGA file populating the referenced TGA structure.
202  *	\param ctx Pointer to TGA binary file
203  *	\param tga Pointer to TGA structure
204  *	\return int 0 on sucess, -1 on failure
205  */
read_image_tga(gdIOCtx * ctx,oTga * tga)206 int read_image_tga( gdIOCtx *ctx, oTga *tga )
207 {
208 	int pixel_block_size = (tga->bits / 8);
209 	int image_block_size;
210 	int* decompression_buffer = NULL;
211 	unsigned char* conversion_buffer = NULL;
212 	int buffer_caret = 0;
213 	int bitmap_caret = 0;
214 	int i = 0;
215 	int encoded_pixels;
216 	int rle_size;
217 
218 	if(overflow2(tga->width, tga->height)) {
219 		return -1;
220 	}
221 
222 	if(overflow2(tga->width * tga->height, pixel_block_size)) {
223 		return -1;
224 	}
225 
226 	image_block_size = (tga->width * tga->height) * pixel_block_size;
227 	if(overflow2(image_block_size, sizeof(int))) {
228 		return -1;
229 	}
230 
231 	/*! \todo Add more image type support.
232 	 */
233 	if (tga->imagetype != TGA_TYPE_RGB && tga->imagetype != TGA_TYPE_RGB_RLE)
234 		return -1;
235 
236 	/*!	\brief Allocate memmory for image block
237 	 *  Allocate a chunk of memory for the image block to be passed into.
238 	 */
239 	tga->bitmap = (int *) gdMalloc(image_block_size * sizeof(int));
240 	if (tga->bitmap == NULL)
241 		return -1;
242 
243 	switch (tga->imagetype) {
244 	case TGA_TYPE_RGB:
245 		/*! \brief Read in uncompressed RGB TGA
246 		 *  Chunk load the pixel data from an uncompressed RGB type TGA.
247 		 */
248 		conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char));
249 		if (conversion_buffer == NULL) {
250 			return -1;
251 		}
252 
253 		if (gdGetBuf(conversion_buffer, image_block_size, ctx) != image_block_size) {
254 			gd_error("gd-tga: premature end of image data\n");
255 			gdFree(conversion_buffer);
256 			return -1;
257 		}
258 
259 		while (buffer_caret < image_block_size) {
260 			tga->bitmap[buffer_caret] = (int) conversion_buffer[buffer_caret];
261 			buffer_caret++;
262 		}
263 
264 		gdFree(conversion_buffer);
265 		break;
266 
267 	case TGA_TYPE_RGB_RLE:
268 		/*! \brief Read in RLE compressed RGB TGA
269 		 *  Chunk load the pixel data from an RLE compressed RGB type TGA.
270 		 */
271 		decompression_buffer = (int*) gdMalloc(image_block_size * sizeof(int));
272 		if (decompression_buffer == NULL) {
273 			return -1;
274 		}
275 		conversion_buffer = (unsigned char *) gdMalloc(image_block_size * sizeof(unsigned char));
276 		if (conversion_buffer == NULL) {
277 			gd_error("gd-tga: premature end of image data\n");
278 			gdFree( decompression_buffer );
279 			return -1;
280 		}
281 
282 		rle_size = gdGetBuf(conversion_buffer, image_block_size, ctx);
283 		if (rle_size <= 0) {
284 			gdFree(conversion_buffer);
285 			gdFree(decompression_buffer);
286 			return -1;
287 		}
288 
289 		buffer_caret = 0;
290 
291 		while( buffer_caret < rle_size) {
292 			decompression_buffer[buffer_caret] = (int)conversion_buffer[buffer_caret];
293 			buffer_caret++;
294 		}
295 
296 		buffer_caret = 0;
297 
298 		while( bitmap_caret < image_block_size ) {
299 
300 			if (buffer_caret + pixel_block_size > rle_size) {
301 				gdFree( decompression_buffer );
302 				gdFree( conversion_buffer );
303 				return -1;
304 			}
305 
306 			if ((decompression_buffer[buffer_caret] & TGA_RLE_FLAG) == TGA_RLE_FLAG) {
307 				encoded_pixels = ( ( decompression_buffer[ buffer_caret ] & ~TGA_RLE_FLAG ) + 1 );
308 				buffer_caret++;
309 
310 				if ((bitmap_caret + (encoded_pixels * pixel_block_size)) > image_block_size
311 						|| buffer_caret + pixel_block_size > rle_size) {
312 					gdFree( decompression_buffer );
313 					gdFree( conversion_buffer );
314 					return -1;
315 				}
316 
317 				for (i = 0; i < encoded_pixels; i++) {
318 					memcpy(tga->bitmap + bitmap_caret, decompression_buffer + buffer_caret, pixel_block_size * sizeof(int));
319 					bitmap_caret += pixel_block_size;
320 				}
321 				buffer_caret += pixel_block_size;
322 
323 			} else {
324 				encoded_pixels = decompression_buffer[ buffer_caret ] + 1;
325 				buffer_caret++;
326 
327 				if ((bitmap_caret + (encoded_pixels * pixel_block_size)) > image_block_size
328 						|| buffer_caret + (encoded_pixels * pixel_block_size) > rle_size) {
329 					gdFree( decompression_buffer );
330 					gdFree( conversion_buffer );
331 					return -1;
332 				}
333 
334 				memcpy(tga->bitmap + bitmap_caret, decompression_buffer + buffer_caret, encoded_pixels * pixel_block_size * sizeof(int));
335 				bitmap_caret += (encoded_pixels * pixel_block_size);
336 				buffer_caret += (encoded_pixels * pixel_block_size);
337 			}
338 		}
339 		gdFree( decompression_buffer );
340 		gdFree( conversion_buffer );
341 		break;
342 	}
343 
344 	return 1;
345 }
346 
347 /*!	\brief Cleans up a TGA structure.
348  *	Dereferences the bitmap referenced in a TGA structure, then the structure itself
349  *	\param tga Pointer to TGA structure
350  */
free_tga(oTga * tga)351 void free_tga(oTga * tga)
352 {
353 	if (tga) {
354 		if (tga->ident)
355 			gdFree(tga->ident);
356 		if (tga->bitmap)
357 			gdFree(tga->bitmap);
358 		gdFree(tga);
359 	}
360 }
361