pngtrans.c
Go to the documentation of this file.
1 
2 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
3  *
4  * Last changed in libpng 1.2.30 [August 15, 2008]
5  * For conditions of distribution and use, see copyright notice in png.h
6  * Copyright (c) 1998-2008 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 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
14 
15 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
16 /* turn on BGR-to-RGB mapping */
17 void PNGAPI
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 */
28 void PNGAPI
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 */
40 void PNGAPI
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 */
55 void PNGAPI
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)
66 void PNGAPI
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)
78 int PNGAPI
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  */
98 void PNGAPI
99 png_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 */
131 void PNGAPI
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)
145 void PNGAPI
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)
156 void PNGAPI
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)
166 void PNGAPI
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 */
175 void /* PRIVATE */
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 */
230 void /* PRIVATE */
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)
256  0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
257  0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
258  0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
259  0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
260  0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
261  0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
262  0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
263  0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
264  0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
265  0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
266  0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
267  0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
268  0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
269  0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
270  0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
271  0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
272  0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
273  0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
274  0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
275  0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
276  0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
277  0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
278  0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
279  0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
280  0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
281  0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
282  0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
283  0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
284  0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
285  0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
286  0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
287  0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
288 };
289 
291  0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
292  0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
293  0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
294  0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
295  0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
296  0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
297  0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
298  0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
299  0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
300  0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
301  0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
302  0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
303  0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
304  0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
305  0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
306  0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
307  0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
308  0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
309  0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
310  0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
311  0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
312  0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
313  0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
314  0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
315  0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
316  0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
317  0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
318  0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
319  0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
320  0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
321  0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
322  0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
323 };
324 
326  0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
327  0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
328  0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
329  0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
330  0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
331  0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
332  0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
333  0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
334  0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
335  0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
336  0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
337  0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
338  0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
339  0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
340  0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
341  0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
342  0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
343  0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
344  0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
345  0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
346  0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
347  0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
348  0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
349  0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
350  0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
351  0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
352  0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
353  0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
354  0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
355  0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
356  0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
357  0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
358 };
359 
360 /* swaps pixel packing order within bytes */
361 void /* PRIVATE */
363 {
364  png_debug(1, "in png_do_packswap\n");
365  if (
366 #if defined(PNG_USELESS_TESTS_SUPPORTED)
367  row != NULL && row_info != NULL &&
368 #endif
369  row_info->bit_depth < 8)
370  {
371  png_bytep rp, end, table;
372 
373  end = row + row_info->rowbytes;
374 
375  if (row_info->bit_depth == 1)
376  table = (png_bytep)onebppswaptable;
377  else if (row_info->bit_depth == 2)
378  table = (png_bytep)twobppswaptable;
379  else if (row_info->bit_depth == 4)
380  table = (png_bytep)fourbppswaptable;
381  else
382  return;
383 
384  for (rp = row; rp < end; rp++)
385  *rp = table[*rp];
386  }
387 }
388 #endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
389 
390 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
391  defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
392 /* remove filler or alpha byte(s) */
393 void /* PRIVATE */
395 {
396  png_debug(1, "in png_do_strip_filler\n");
397 #if defined(PNG_USELESS_TESTS_SUPPORTED)
398  if (row != NULL && row_info != NULL)
399 #endif
400  {
401  png_bytep sp=row;
402  png_bytep dp=row;
403  png_uint_32 row_width=row_info->width;
404  png_uint_32 i;
405 
406  if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
407  (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
408  (flags & PNG_FLAG_STRIP_ALPHA))) &&
409  row_info->channels == 4)
410  {
411  if (row_info->bit_depth == 8)
412  {
413  /* This converts from RGBX or RGBA to RGB */
414  if (flags & PNG_FLAG_FILLER_AFTER)
415  {
416  dp+=3; sp+=4;
417  for (i = 1; i < row_width; i++)
418  {
419  *dp++ = *sp++;
420  *dp++ = *sp++;
421  *dp++ = *sp++;
422  sp++;
423  }
424  }
425  /* This converts from XRGB or ARGB to RGB */
426  else
427  {
428  for (i = 0; i < row_width; i++)
429  {
430  sp++;
431  *dp++ = *sp++;
432  *dp++ = *sp++;
433  *dp++ = *sp++;
434  }
435  }
436  row_info->pixel_depth = 24;
437  row_info->rowbytes = row_width * 3;
438  }
439  else /* if (row_info->bit_depth == 16) */
440  {
441  if (flags & PNG_FLAG_FILLER_AFTER)
442  {
443  /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
444  sp += 8; dp += 6;
445  for (i = 1; i < row_width; i++)
446  {
447  /* This could be (although png_memcpy is probably slower):
448  png_memcpy(dp, sp, 6);
449  sp += 8;
450  dp += 6;
451  */
452 
453  *dp++ = *sp++;
454  *dp++ = *sp++;
455  *dp++ = *sp++;
456  *dp++ = *sp++;
457  *dp++ = *sp++;
458  *dp++ = *sp++;
459  sp += 2;
460  }
461  }
462  else
463  {
464  /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
465  for (i = 0; i < row_width; i++)
466  {
467  /* This could be (although png_memcpy is probably slower):
468  png_memcpy(dp, sp, 6);
469  sp += 8;
470  dp += 6;
471  */
472 
473  sp+=2;
474  *dp++ = *sp++;
475  *dp++ = *sp++;
476  *dp++ = *sp++;
477  *dp++ = *sp++;
478  *dp++ = *sp++;
479  *dp++ = *sp++;
480  }
481  }
482  row_info->pixel_depth = 48;
483  row_info->rowbytes = row_width * 6;
484  }
485  row_info->channels = 3;
486  }
487  else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||
488  (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
489  (flags & PNG_FLAG_STRIP_ALPHA))) &&
490  row_info->channels == 2)
491  {
492  if (row_info->bit_depth == 8)
493  {
494  /* This converts from GX or GA to G */
495  if (flags & PNG_FLAG_FILLER_AFTER)
496  {
497  for (i = 0; i < row_width; i++)
498  {
499  *dp++ = *sp++;
500  sp++;
501  }
502  }
503  /* This converts from XG or AG to G */
504  else
505  {
506  for (i = 0; i < row_width; i++)
507  {
508  sp++;
509  *dp++ = *sp++;
510  }
511  }
512  row_info->pixel_depth = 8;
513  row_info->rowbytes = row_width;
514  }
515  else /* if (row_info->bit_depth == 16) */
516  {
517  if (flags & PNG_FLAG_FILLER_AFTER)
518  {
519  /* This converts from GGXX or GGAA to GG */
520  sp += 4; dp += 2;
521  for (i = 1; i < row_width; i++)
522  {
523  *dp++ = *sp++;
524  *dp++ = *sp++;
525  sp += 2;
526  }
527  }
528  else
529  {
530  /* This converts from XXGG or AAGG to GG */
531  for (i = 0; i < row_width; i++)
532  {
533  sp += 2;
534  *dp++ = *sp++;
535  *dp++ = *sp++;
536  }
537  }
538  row_info->pixel_depth = 16;
539  row_info->rowbytes = row_width * 2;
540  }
541  row_info->channels = 1;
542  }
543  if (flags & PNG_FLAG_STRIP_ALPHA)
544  row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
545  }
546 }
547 #endif
548 
549 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
550 /* swaps red and blue bytes within a pixel */
551 void /* PRIVATE */
553 {
554  png_debug(1, "in png_do_bgr\n");
555  if (
556 #if defined(PNG_USELESS_TESTS_SUPPORTED)
557  row != NULL && row_info != NULL &&
558 #endif
559  (row_info->color_type & PNG_COLOR_MASK_COLOR))
560  {
561  png_uint_32 row_width = row_info->width;
562  if (row_info->bit_depth == 8)
563  {
564  if (row_info->color_type == PNG_COLOR_TYPE_RGB)
565  {
566  png_bytep rp;
567  png_uint_32 i;
568 
569  for (i = 0, rp = row; i < row_width; i++, rp += 3)
570  {
571  png_byte save = *rp;
572  *rp = *(rp + 2);
573  *(rp + 2) = save;
574  }
575  }
576  else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
577  {
578  png_bytep rp;
579  png_uint_32 i;
580 
581  for (i = 0, rp = row; i < row_width; i++, rp += 4)
582  {
583  png_byte save = *rp;
584  *rp = *(rp + 2);
585  *(rp + 2) = save;
586  }
587  }
588  }
589  else if (row_info->bit_depth == 16)
590  {
591  if (row_info->color_type == PNG_COLOR_TYPE_RGB)
592  {
593  png_bytep rp;
594  png_uint_32 i;
595 
596  for (i = 0, rp = row; i < row_width; i++, rp += 6)
597  {
598  png_byte save = *rp;
599  *rp = *(rp + 4);
600  *(rp + 4) = save;
601  save = *(rp + 1);
602  *(rp + 1) = *(rp + 5);
603  *(rp + 5) = save;
604  }
605  }
606  else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
607  {
608  png_bytep rp;
609  png_uint_32 i;
610 
611  for (i = 0, rp = row; i < row_width; i++, rp += 8)
612  {
613  png_byte save = *rp;
614  *rp = *(rp + 4);
615  *(rp + 4) = save;
616  save = *(rp + 1);
617  *(rp + 1) = *(rp + 5);
618  *(rp + 5) = save;
619  }
620  }
621  }
622  }
623 }
624 #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
625 
626 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
627  defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
628  defined(PNG_LEGACY_SUPPORTED)
629 void PNGAPI
632 {
633  png_debug(1, "in png_set_user_transform_info\n");
634  if (png_ptr == NULL) return;
635 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
636  png_ptr->user_transform_ptr = user_transform_ptr;
637  png_ptr->user_transform_depth = (png_byte)user_transform_depth;
638  png_ptr->user_transform_channels = (png_byte)user_transform_channels;
639 #else
640  if (user_transform_ptr || user_transform_depth || user_transform_channels)
641  png_warning(png_ptr,
642  "This version of libpng does not support user transform info");
643 #endif
644 }
645 #endif
646 
647 /* This function returns a pointer to the user_transform_ptr associated with
648  * the user transform functions. The application should free any memory
649  * associated with this pointer before png_write_destroy and png_read_destroy
650  * are called.
651  */
654 {
655  if (png_ptr == NULL) return (NULL);
656 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
657  return ((png_voidp)png_ptr->user_transform_ptr);
658 #else
659  return (NULL);
660 #endif
661 }
662 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
void PNGAPI png_set_packing(png_structp png_ptr)
Definition: pngtrans.c:41
void PNGAPI png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
Definition: pngtrans.c:132
void png_do_packswap(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:362
void png_do_invert(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:176
png_voidp int int user_transform_channels
Definition: png.h:2013
png_voidp user_transform_ptr
Definition: png.h:2013
#define PNG_COLOR_TYPE_RGB
Definition: png.h:1005
void PNGAPI png_set_invert_alpha(png_structp png_ptr)
Definition: pngtrans.c:157
#define PNG_COLOR_TYPE_GRAY_ALPHA
Definition: png.h:1007
png_byte FAR * png_bytep
Definition: pngconf.h:1197
void png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
Definition: pngtrans.c:394
#define PNG_COLOR_TYPE_RGB_ALPHA
Definition: png.h:1006
png_uint_32 i
Definition: png.h:2735
png_voidp int user_transform_depth
Definition: png.h:2013
png_uint_32 int flags
Definition: png.h:1656
void PNGAPI png_set_user_transform_info(png_structp png_ptr, png_voidp user_transform_ptr, int user_transform_depth, int user_transform_channels)
Definition: pngtrans.c:630
void PNGAPI png_set_bgr(png_structp png_ptr)
Definition: pngtrans.c:18
static PNG_CONST png_byte onebppswaptable[256]
Definition: pngtrans.c:255
#define png_debug(l, m)
Definition: png.h:2556
#define PNGAPI
Definition: pngconf.h:1386
png_struct FAR * png_structp
Definition: png.h:1108
png_voidp PNGAPI png_get_user_transform_ptr(png_structp png_ptr)
Definition: pngtrans.c:653
void PNGAPI png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
Definition: pngtrans.c:99
#define PNG_COLOR_MASK_COLOR
Definition: png.h:999
void PNGAPI png_set_packswap(png_structp png_ptr)
Definition: pngtrans.c:56
#define PNG_CONST
Definition: pngconf.h:445
void PNGAPI png_set_swap(png_structp png_ptr)
Definition: pngtrans.c:29
unsigned char png_byte
Definition: pngconf.h:1120
#define PNG_COLOR_TYPE_GRAY
Definition: png.h:1003
void PNGAPI png_warning(png_structp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:102
void png_do_bgr(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:552
t
png_bytepp row
Definition: png.h:1759
void PNGAPI png_set_invert_mono(png_structp png_ptr)
Definition: pngtrans.c:167
png_color_8p true_bits
Definition: png.h:1685
#define PNG_COLOR_MASK_ALPHA
Definition: png.h:1000
void png_do_swap(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:231
png_color_8 FAR * png_color_8p
Definition: png.h:593
int PNGAPI png_set_interlace_handling(png_structp png_ptr)
Definition: pngtrans.c:79
void FAR * png_voidp
Definition: pngconf.h:1196
void PNGAPI png_set_shift(png_structp png_ptr, png_color_8p true_bits)
Definition: pngtrans.c:67
#define PNG_FILLER_AFTER
Definition: png.h:1659
unsigned long png_uint_32
Definition: pngconf.h:1116
png_row_info FAR * png_row_infop
Definition: png.h:1098
static PNG_CONST png_byte twobppswaptable[256]
Definition: pngtrans.c:290
void PNGAPI png_set_swap_alpha(png_structp png_ptr)
Definition: pngtrans.c:146
png_uint_32 filler
Definition: png.h:1656
static PNG_CONST png_byte fourbppswaptable[256]
Definition: pngtrans.c:325


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Thu Sep 8 2022 02:24:05