source: liacs/MIR2010/Sample/cximage/png/pngtrans.c@ 93

Last change on this file since 93 was 93, checked in by Rick van der Zwet, 15 years ago

Sample implementation of professor
File size: 21.2 KB
RevLine 
[93]1
2/* pngtrans.c - transforms the data in a row (used by both readers and writers)
3 *
4 * Last changed in libpng 1.2.13 November 13, 2006
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1998-2006 Glenn Randers-Pehrson
7 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
8 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9 */
10
11#define PNG_INTERNAL
12#include "png.h"
13
14#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
15#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
16/* turn on BGR-to-RGB mapping */
17void PNGAPI
18png_set_bgr(png_structp png_ptr)
19{
20 png_debug(1, "in png_set_bgr\n");
21 if(png_ptr == NULL) return;
22 png_ptr->transformations |= PNG_BGR;
23}
24#endif
25
26#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
27/* turn on 16 bit byte swapping */
28void PNGAPI
29png_set_swap(png_structp png_ptr)
30{
31 png_debug(1, "in png_set_swap\n");
32 if(png_ptr == NULL) return;
33 if (png_ptr->bit_depth == 16)
34 png_ptr->transformations |= PNG_SWAP_BYTES;
35}
36#endif
37
38#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
39/* turn on pixel packing */
40void PNGAPI
41png_set_packing(png_structp png_ptr)
42{
43 png_debug(1, "in png_set_packing\n");
44 if(png_ptr == NULL) return;
45 if (png_ptr->bit_depth < 8)
46 {
47 png_ptr->transformations |= PNG_PACK;
48 png_ptr->usr_bit_depth = 8;
49 }
50}
51#endif
52
53#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
54/* turn on packed pixel swapping */
55void PNGAPI
56png_set_packswap(png_structp png_ptr)
57{
58 png_debug(1, "in png_set_packswap\n");
59 if(png_ptr == NULL) return;
60 if (png_ptr->bit_depth < 8)
61 png_ptr->transformations |= PNG_PACKSWAP;
62}
63#endif
64
65#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
66void PNGAPI
67png_set_shift(png_structp png_ptr, png_color_8p true_bits)
68{
69 png_debug(1, "in png_set_shift\n");
70 if(png_ptr == NULL) return;
71 png_ptr->transformations |= PNG_SHIFT;
72 png_ptr->shift = *true_bits;
73}
74#endif
75
76#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
77 defined(PNG_WRITE_INTERLACING_SUPPORTED)
78int PNGAPI
79png_set_interlace_handling(png_structp png_ptr)
80{
81 png_debug(1, "in png_set_interlace handling\n");
82 if (png_ptr && png_ptr->interlaced)
83 {
84 png_ptr->transformations |= PNG_INTERLACE;
85 return (7);
86 }
87
88 return (1);
89}
90#endif
91
92#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
93/* Add a filler byte on read, or remove a filler or alpha byte on write.
94 * The filler type has changed in v0.95 to allow future 2-byte fillers
95 * for 48-bit input data, as well as to avoid problems with some compilers
96 * that don't like bytes as parameters.
97 */
98void PNGAPI
99png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
100{
101 png_debug(1, "in png_set_filler\n");
102 if(png_ptr == NULL) return;
103 png_ptr->transformations |= PNG_FILLER;
104 png_ptr->filler = (png_byte)filler;
105 if (filler_loc == PNG_FILLER_AFTER)
106 png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
107 else
108 png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
109
110 /* This should probably go in the "do_read_filler" routine.
111 * I attempted to do that in libpng-1.0.1a but that caused problems
112 * so I restored it in libpng-1.0.2a
113 */
114
115 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
116 {
117 png_ptr->usr_channels = 4;
118 }
119
120 /* Also I added this in libpng-1.0.2a (what happens when we expand
121 * a less-than-8-bit grayscale to GA? */
122
123 if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
124 {
125 png_ptr->usr_channels = 2;
126 }
127}
128
129#if !defined(PNG_1_0_X)
130/* Added to libpng-1.2.7 */
131void PNGAPI
132png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
133{
134 png_debug(1, "in png_set_add_alpha\n");
135 if(png_ptr == NULL) return;
136 png_set_filler(png_ptr, filler, filler_loc);
137 png_ptr->transformations |= PNG_ADD_ALPHA;
138}
139#endif
140
141#endif
142
143#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
144 defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
145void PNGAPI
146png_set_swap_alpha(png_structp png_ptr)
147{
148 png_debug(1, "in png_set_swap_alpha\n");
149 if(png_ptr == NULL) return;
150 png_ptr->transformations |= PNG_SWAP_ALPHA;
151}
152#endif
153
154#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
155 defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
156void PNGAPI
157png_set_invert_alpha(png_structp png_ptr)
158{
159 png_debug(1, "in png_set_invert_alpha\n");
160 if(png_ptr == NULL) return;
161 png_ptr->transformations |= PNG_INVERT_ALPHA;
162}
163#endif
164
165#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
166void PNGAPI
167png_set_invert_mono(png_structp png_ptr)
168{
169 png_debug(1, "in png_set_invert_mono\n");
170 if(png_ptr == NULL) return;
171 png_ptr->transformations |= PNG_INVERT_MONO;
172}
173
174/* invert monochrome grayscale data */
175void /* PRIVATE */
176png_do_invert(png_row_infop row_info, png_bytep row)
177{
178 png_debug(1, "in png_do_invert\n");
179 /* This test removed from libpng version 1.0.13 and 1.2.0:
180 * if (row_info->bit_depth == 1 &&
181 */
182#if defined(PNG_USELESS_TESTS_SUPPORTED)
183 if (row == NULL || row_info == NULL)
184 return;
185#endif
186 if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
187 {
188 png_bytep rp = row;
189 png_uint_32 i;
190 png_uint_32 istop = row_info->rowbytes;
191
192 for (i = 0; i < istop; i++)
193 {
194 *rp = (png_byte)(~(*rp));
195 rp++;
196 }
197 }
198 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
199 row_info->bit_depth == 8)
200 {
201 png_bytep rp = row;
202 png_uint_32 i;
203 png_uint_32 istop = row_info->rowbytes;
204
205 for (i = 0; i < istop; i+=2)
206 {
207 *rp = (png_byte)(~(*rp));
208 rp+=2;
209 }
210 }
211 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
212 row_info->bit_depth == 16)
213 {
214 png_bytep rp = row;
215 png_uint_32 i;
216 png_uint_32 istop = row_info->rowbytes;
217
218 for (i = 0; i < istop; i+=4)
219 {
220 *rp = (png_byte)(~(*rp));
221 *(rp+1) = (png_byte)(~(*(rp+1)));
222 rp+=4;
223 }
224 }
225}
226#endif
227
228#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
229/* swaps byte order on 16 bit depth images */
230void /* PRIVATE */
231png_do_swap(png_row_infop row_info, png_bytep row)
232{
233 png_debug(1, "in png_do_swap\n");
234 if (
235#if defined(PNG_USELESS_TESTS_SUPPORTED)
236 row != NULL && row_info != NULL &&
237#endif
238 row_info->bit_depth == 16)
239 {
240 png_bytep rp = row;
241 png_uint_32 i;
242 png_uint_32 istop= row_info->width * row_info->channels;
243
244 for (i = 0; i < istop; i++, rp += 2)
245 {
246 png_byte t = *rp;
247 *rp = *(rp + 1);
248 *(rp + 1) = t;
249 }
250 }
251}
252#endif
253
254#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
255// BT: removed PNG_CONST, since const was already present
256const static png_byte onebppswaptable[256] = {
257 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
258 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
259 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
260 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
261 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
262 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
263 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
264 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
265 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
266 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
267 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
268 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
269 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
270 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
271 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
272 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
273 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
274 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
275 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
276 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
277 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
278 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
279 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
280 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
281 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
282 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
283 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
284 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
285 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
286 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
287 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
288 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
289};
290
291// BT: removed PNG_CONST, since const was already present
292const static png_byte twobppswaptable[256] = {
293 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
294 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
295 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
296 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
297 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
298 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
299 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
300 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
301 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
302 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
303 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
304 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
305 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
306 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
307 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
308 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
309 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
310 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
311 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
312 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
313 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
314 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
315 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
316 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
317 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
318 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
319 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
320 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
321 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
322 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
323 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
324 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
325};
326
327// BT: removed PNG_CONST, since const was already present
328const static png_byte fourbppswaptable[256] = {
329 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
330 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
331 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
332 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
333 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
334 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
335 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
336 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
337 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
338 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
339 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
340 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
341 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
342 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
343 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
344 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
345 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
346 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
347 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
348 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
349 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
350 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
351 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
352 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
353 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
354 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
355 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
356 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
357 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
358 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
359 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
360 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
361};
362
363/* swaps pixel packing order within bytes */
364void /* PRIVATE */
365png_do_packswap(png_row_infop row_info, png_bytep row)
366{
367 png_debug(1, "in png_do_packswap\n");
368 if (
369#if defined(PNG_USELESS_TESTS_SUPPORTED)
370 row != NULL && row_info != NULL &&
371#endif
372 row_info->bit_depth < 8)
373 {
374 png_bytep rp, end, table;
375
376 end = row + row_info->rowbytes;
377
378 if (row_info->bit_depth == 1)
379 table = (png_bytep)onebppswaptable;
380 else if (row_info->bit_depth == 2)
381 table = (png_bytep)twobppswaptable;
382 else if (row_info->bit_depth == 4)
383 table = (png_bytep)fourbppswaptable;
384 else
385 return;
386
387 for (rp = row; rp < end; rp++)
388 *rp = table[*rp];
389 }
390}
391#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
392
393#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
394 defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
395/* remove filler or alpha byte(s) */
396void /* PRIVATE */
397png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
398{
399 png_debug(1, "in png_do_strip_filler\n");
400#if defined(PNG_USELESS_TESTS_SUPPORTED)
401 if (row != NULL && row_info != NULL)
402#endif
403 {
404 png_bytep sp=row;
405 png_bytep dp=row;
406 png_uint_32 row_width=row_info->width;
407 png_uint_32 i;
408
409 if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
410 (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
411 (flags & PNG_FLAG_STRIP_ALPHA))) &&
412 row_info->channels == 4)
413 {
414 if (row_info->bit_depth == 8)
415 {
416 /* This converts from RGBX or RGBA to RGB */
417 if (flags & PNG_FLAG_FILLER_AFTER)
418 {
419 dp+=3; sp+=4;
420 for (i = 1; i < row_width; i++)
421 {
422 *dp++ = *sp++;
423 *dp++ = *sp++;
424 *dp++ = *sp++;
425 sp++;
426 }
427 }
428 /* This converts from XRGB or ARGB to RGB */
429 else
430 {
431 for (i = 0; i < row_width; i++)
432 {
433 sp++;
434 *dp++ = *sp++;
435 *dp++ = *sp++;
436 *dp++ = *sp++;
437 }
438 }
439 row_info->pixel_depth = 24;
440 row_info->rowbytes = row_width * 3;
441 }
442 else /* if (row_info->bit_depth == 16) */
443 {
444 if (flags & PNG_FLAG_FILLER_AFTER)
445 {
446 /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
447 sp += 8; dp += 6;
448 for (i = 1; i < row_width; i++)
449 {
450 /* This could be (although png_memcpy is probably slower):
451 png_memcpy(dp, sp, 6);
452 sp += 8;
453 dp += 6;
454 */
455
456 *dp++ = *sp++;
457 *dp++ = *sp++;
458 *dp++ = *sp++;
459 *dp++ = *sp++;
460 *dp++ = *sp++;
461 *dp++ = *sp++;
462 sp += 2;
463 }
464 }
465 else
466 {
467 /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
468 for (i = 0; i < row_width; i++)
469 {
470 /* This could be (although png_memcpy is probably slower):
471 png_memcpy(dp, sp, 6);
472 sp += 8;
473 dp += 6;
474 */
475
476 sp+=2;
477 *dp++ = *sp++;
478 *dp++ = *sp++;
479 *dp++ = *sp++;
480 *dp++ = *sp++;
481 *dp++ = *sp++;
482 *dp++ = *sp++;
483 }
484 }
485 row_info->pixel_depth = 48;
486 row_info->rowbytes = row_width * 6;
487 }
488 row_info->channels = 3;
489 }
490 else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||
491 (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
492 (flags & PNG_FLAG_STRIP_ALPHA))) &&
493 row_info->channels == 2)
494 {
495 if (row_info->bit_depth == 8)
496 {
497 /* This converts from GX or GA to G */
498 if (flags & PNG_FLAG_FILLER_AFTER)
499 {
500 for (i = 0; i < row_width; i++)
501 {
502 *dp++ = *sp++;
503 sp++;
504 }
505 }
506 /* This converts from XG or AG to G */
507 else
508 {
509 for (i = 0; i < row_width; i++)
510 {
511 sp++;
512 *dp++ = *sp++;
513 }
514 }
515 row_info->pixel_depth = 8;
516 row_info->rowbytes = row_width;
517 }
518 else /* if (row_info->bit_depth == 16) */
519 {
520 if (flags & PNG_FLAG_FILLER_AFTER)
521 {
522 /* This converts from GGXX or GGAA to GG */
523 sp += 4; dp += 2;
524 for (i = 1; i < row_width; i++)
525 {
526 *dp++ = *sp++;
527 *dp++ = *sp++;
528 sp += 2;
529 }
530 }
531 else
532 {
533 /* This converts from XXGG or AAGG to GG */
534 for (i = 0; i < row_width; i++)
535 {
536 sp += 2;
537 *dp++ = *sp++;
538 *dp++ = *sp++;
539 }
540 }
541 row_info->pixel_depth = 16;
542 row_info->rowbytes = row_width * 2;
543 }
544 row_info->channels = 1;
545 }
546 if (flags & PNG_FLAG_STRIP_ALPHA)
547 row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
548 }
549}
550#endif
551
552#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
553/* swaps red and blue bytes within a pixel */
554void /* PRIVATE */
555png_do_bgr(png_row_infop row_info, png_bytep row)
556{
557 png_debug(1, "in png_do_bgr\n");
558 if (
559#if defined(PNG_USELESS_TESTS_SUPPORTED)
560 row != NULL && row_info != NULL &&
561#endif
562 (row_info->color_type & PNG_COLOR_MASK_COLOR))
563 {
564 png_uint_32 row_width = row_info->width;
565 if (row_info->bit_depth == 8)
566 {
567 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
568 {
569 png_bytep rp;
570 png_uint_32 i;
571
572 for (i = 0, rp = row; i < row_width; i++, rp += 3)
573 {
574 png_byte save = *rp;
575 *rp = *(rp + 2);
576 *(rp + 2) = save;
577 }
578 }
579 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
580 {
581 png_bytep rp;
582 png_uint_32 i;
583
584 for (i = 0, rp = row; i < row_width; i++, rp += 4)
585 {
586 png_byte save = *rp;
587 *rp = *(rp + 2);
588 *(rp + 2) = save;
589 }
590 }
591 }
592 else if (row_info->bit_depth == 16)
593 {
594 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
595 {
596 png_bytep rp;
597 png_uint_32 i;
598
599 for (i = 0, rp = row; i < row_width; i++, rp += 6)
600 {
601 png_byte save = *rp;
602 *rp = *(rp + 4);
603 *(rp + 4) = save;
604 save = *(rp + 1);
605 *(rp + 1) = *(rp + 5);
606 *(rp + 5) = save;
607 }
608 }
609 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
610 {
611 png_bytep rp;
612 png_uint_32 i;
613
614 for (i = 0, rp = row; i < row_width; i++, rp += 8)
615 {
616 png_byte save = *rp;
617 *rp = *(rp + 4);
618 *(rp + 4) = save;
619 save = *(rp + 1);
620 *(rp + 1) = *(rp + 5);
621 *(rp + 5) = save;
622 }
623 }
624 }
625 }
626}
627#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
628
629#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
630 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
631 defined(PNG_LEGACY_SUPPORTED)
632void PNGAPI
633png_set_user_transform_info(png_structp png_ptr, png_voidp
634 user_transform_ptr, int user_transform_depth, int user_transform_channels)
635{
636 png_debug(1, "in png_set_user_transform_info\n");
637 if(png_ptr == NULL) return;
638#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
639 png_ptr->user_transform_ptr = user_transform_ptr;
640 png_ptr->user_transform_depth = (png_byte)user_transform_depth;
641 png_ptr->user_transform_channels = (png_byte)user_transform_channels;
642#else
643 if(user_transform_ptr || user_transform_depth || user_transform_channels)
644 png_warning(png_ptr,
645 "This version of libpng does not support user transform info");
646#endif
647}
648#endif
649
650/* This function returns a pointer to the user_transform_ptr associated with
651 * the user transform functions. The application should free any memory
652 * associated with this pointer before png_write_destroy and png_read_destroy
653 * are called.
654 */
655png_voidp PNGAPI
656png_get_user_transform_ptr(png_structp png_ptr)
657{
658#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
659 if (png_ptr == NULL) return (NULL);
660 return ((png_voidp)png_ptr->user_transform_ptr);
661#else
662 return (NULL);
663#endif
664}
665#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
Note: See TracBrowser for help on using the repository browser.