Cleanup: Get this rid of "this->" in fpdfsdk/
[pdfium.git] / samples / fx_lpng / lpng_v163 / fx_pngtrans.c
1 /* pngtrans.c - transforms the data in a row (used by both readers and writers)\r
2  *\r
3  * Last changed in libpng 1.6.2 [April 25, 2013]\r
4  * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
5  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
6  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
7  *\r
8  * This code is released under the libpng license.\r
9  * For conditions of distribution and use, see the disclaimer\r
10  * and license in png.h\r
11  */\r
12 \r
13 #include "pngpriv.h"\r
14 \r
15 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
16 \r
17 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)\r
18 /* Turn on BGR-to-RGB mapping */\r
19 void PNGAPI\r
20 png_set_bgr(png_structrp png_ptr)\r
21 {\r
22    png_debug(1, "in png_set_bgr");\r
23 \r
24    if (png_ptr == NULL)\r
25       return;\r
26 \r
27    png_ptr->transformations |= PNG_BGR;\r
28 }\r
29 #endif\r
30 \r
31 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)\r
32 /* Turn on 16 bit byte swapping */\r
33 void PNGAPI\r
34 png_set_swap(png_structrp png_ptr)\r
35 {\r
36    png_debug(1, "in png_set_swap");\r
37 \r
38    if (png_ptr == NULL)\r
39       return;\r
40 \r
41    if (png_ptr->bit_depth == 16)\r
42       png_ptr->transformations |= PNG_SWAP_BYTES;\r
43 }\r
44 #endif\r
45 \r
46 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)\r
47 /* Turn on pixel packing */\r
48 void PNGAPI\r
49 png_set_packing(png_structrp png_ptr)\r
50 {\r
51    png_debug(1, "in png_set_packing");\r
52 \r
53    if (png_ptr == NULL)\r
54       return;\r
55 \r
56    if (png_ptr->bit_depth < 8)\r
57    {\r
58       png_ptr->transformations |= PNG_PACK;\r
59       png_ptr->usr_bit_depth = 8;\r
60    }\r
61 }\r
62 #endif\r
63 \r
64 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
65 /* Turn on packed pixel swapping */\r
66 void PNGAPI\r
67 png_set_packswap(png_structrp png_ptr)\r
68 {\r
69    png_debug(1, "in png_set_packswap");\r
70 \r
71    if (png_ptr == NULL)\r
72       return;\r
73 \r
74    if (png_ptr->bit_depth < 8)\r
75       png_ptr->transformations |= PNG_PACKSWAP;\r
76 }\r
77 #endif\r
78 \r
79 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)\r
80 void PNGAPI\r
81 png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits)\r
82 {\r
83    png_debug(1, "in png_set_shift");\r
84 \r
85    if (png_ptr == NULL)\r
86       return;\r
87 \r
88    png_ptr->transformations |= PNG_SHIFT;\r
89    png_ptr->shift = *true_bits;\r
90 }\r
91 #endif\r
92 \r
93 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \\r
94     defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
95 int PNGAPI\r
96 png_set_interlace_handling(png_structrp png_ptr)\r
97 {\r
98    png_debug(1, "in png_set_interlace handling");\r
99 \r
100    if (png_ptr && png_ptr->interlaced)\r
101    {\r
102       png_ptr->transformations |= PNG_INTERLACE;\r
103       return (7);\r
104    }\r
105 \r
106    return (1);\r
107 }\r
108 #endif\r
109 \r
110 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)\r
111 /* Add a filler byte on read, or remove a filler or alpha byte on write.\r
112  * The filler type has changed in v0.95 to allow future 2-byte fillers\r
113  * for 48-bit input data, as well as to avoid problems with some compilers\r
114  * that don't like bytes as parameters.\r
115  */\r
116 void PNGAPI\r
117 png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)\r
118 {\r
119    png_debug(1, "in png_set_filler");\r
120 \r
121    if (png_ptr == NULL)\r
122       return;\r
123 \r
124    /* In libpng 1.6 it is possible to determine whether this is a read or write\r
125     * operation and therefore to do more checking here for a valid call.\r
126     */\r
127    if (png_ptr->mode & PNG_IS_READ_STRUCT)\r
128    {\r
129 #     ifdef PNG_READ_FILLER_SUPPORTED\r
130          /* On read png_set_filler is always valid, regardless of the base PNG\r
131           * format, because other transformations can give a format where the\r
132           * filler code can execute (basically an 8 or 16-bit component RGB or G\r
133           * format.)\r
134           *\r
135           * NOTE: usr_channels is not used by the read code!  (This has led to\r
136           * confusion in the past.)  The filler is only used in the read code.\r
137           */\r
138          png_ptr->filler = (png_uint_16)filler;\r
139 #     else\r
140          png_app_error(png_ptr, "png_set_filler not supported on read");\r
141          PNG_UNUSED(filler) /* not used in the write case */\r
142          return;\r
143 #     endif\r
144    }\r
145 \r
146    else /* write */\r
147    {\r
148 #     ifdef PNG_WRITE_FILLER_SUPPORTED\r
149          /* On write the usr_channels parameter must be set correctly at the\r
150           * start to record the number of channels in the app-supplied data.\r
151           */\r
152          switch (png_ptr->color_type)\r
153          {\r
154             case PNG_COLOR_TYPE_RGB:\r
155                png_ptr->usr_channels = 4;\r
156                break;\r
157 \r
158             case PNG_COLOR_TYPE_GRAY:\r
159                if (png_ptr->bit_depth >= 8)\r
160                {\r
161                   png_ptr->usr_channels = 2;\r
162                   break;\r
163                }\r
164 \r
165                else\r
166                {\r
167                   /* There simply isn't any code in libpng to strip out bits\r
168                    * from bytes when the components are less than a byte in\r
169                    * size!\r
170                    */\r
171                   png_app_error(png_ptr,\r
172                      "png_set_filler is invalid for low bit depth gray output");\r
173                   return;\r
174                }\r
175 \r
176             default:\r
177                png_app_error(png_ptr,\r
178                   "png_set_filler: inappropriate color type");\r
179                return;\r
180          }\r
181 #     else\r
182          png_app_error(png_ptr, "png_set_filler not supported on write");\r
183          return;\r
184 #     endif\r
185    }\r
186 \r
187    /* Here on success - libpng supports the operation, set the transformation\r
188     * and the flag to say where the filler channel is.\r
189     */\r
190    png_ptr->transformations |= PNG_FILLER;\r
191 \r
192    if (filler_loc == PNG_FILLER_AFTER)\r
193       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;\r
194 \r
195    else\r
196       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;\r
197 }\r
198 \r
199 /* Added to libpng-1.2.7 */\r
200 void PNGAPI\r
201 png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)\r
202 {\r
203    png_debug(1, "in png_set_add_alpha");\r
204 \r
205    if (png_ptr == NULL)\r
206       return;\r
207 \r
208    png_set_filler(png_ptr, filler, filler_loc);\r
209    /* The above may fail to do anything. */\r
210    if (png_ptr->transformations & PNG_FILLER)\r
211       png_ptr->transformations |= PNG_ADD_ALPHA;\r
212 }\r
213 \r
214 #endif\r
215 \r
216 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \\r
217     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)\r
218 void PNGAPI\r
219 png_set_swap_alpha(png_structrp png_ptr)\r
220 {\r
221    png_debug(1, "in png_set_swap_alpha");\r
222 \r
223    if (png_ptr == NULL)\r
224       return;\r
225 \r
226    png_ptr->transformations |= PNG_SWAP_ALPHA;\r
227 }\r
228 #endif\r
229 \r
230 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \\r
231     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
232 void PNGAPI\r
233 png_set_invert_alpha(png_structrp png_ptr)\r
234 {\r
235    png_debug(1, "in png_set_invert_alpha");\r
236 \r
237    if (png_ptr == NULL)\r
238       return;\r
239 \r
240    png_ptr->transformations |= PNG_INVERT_ALPHA;\r
241 }\r
242 #endif\r
243 \r
244 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)\r
245 void PNGAPI\r
246 png_set_invert_mono(png_structrp png_ptr)\r
247 {\r
248    png_debug(1, "in png_set_invert_mono");\r
249 \r
250    if (png_ptr == NULL)\r
251       return;\r
252 \r
253    png_ptr->transformations |= PNG_INVERT_MONO;\r
254 }\r
255 \r
256 /* Invert monochrome grayscale data */\r
257 void /* PRIVATE */\r
258 png_do_invert(png_row_infop row_info, png_bytep row)\r
259 {\r
260    png_debug(1, "in png_do_invert");\r
261 \r
262   /* This test removed from libpng version 1.0.13 and 1.2.0:\r
263    *   if (row_info->bit_depth == 1 &&\r
264    */\r
265    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)\r
266    {\r
267       png_bytep rp = row;\r
268       png_size_t i;\r
269       png_size_t istop = row_info->rowbytes;\r
270 \r
271       for (i = 0; i < istop; i++)\r
272       {\r
273          *rp = (png_byte)(~(*rp));\r
274          rp++;\r
275       }\r
276    }\r
277 \r
278    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&\r
279       row_info->bit_depth == 8)\r
280    {\r
281       png_bytep rp = row;\r
282       png_size_t i;\r
283       png_size_t istop = row_info->rowbytes;\r
284 \r
285       for (i = 0; i < istop; i += 2)\r
286       {\r
287          *rp = (png_byte)(~(*rp));\r
288          rp += 2;\r
289       }\r
290    }\r
291 \r
292 #ifdef PNG_16BIT_SUPPORTED\r
293    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&\r
294       row_info->bit_depth == 16)\r
295    {\r
296       png_bytep rp = row;\r
297       png_size_t i;\r
298       png_size_t istop = row_info->rowbytes;\r
299 \r
300       for (i = 0; i < istop; i += 4)\r
301       {\r
302          *rp = (png_byte)(~(*rp));\r
303          *(rp + 1) = (png_byte)(~(*(rp + 1)));\r
304          rp += 4;\r
305       }\r
306    }\r
307 #endif\r
308 }\r
309 #endif\r
310 \r
311 #ifdef PNG_16BIT_SUPPORTED\r
312 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)\r
313 /* Swaps byte order on 16 bit depth images */\r
314 void /* PRIVATE */\r
315 png_do_swap(png_row_infop row_info, png_bytep row)\r
316 {\r
317    png_debug(1, "in png_do_swap");\r
318 \r
319    if (row_info->bit_depth == 16)\r
320    {\r
321       png_bytep rp = row;\r
322       png_uint_32 i;\r
323       png_uint_32 istop= row_info->width * row_info->channels;\r
324 \r
325       for (i = 0; i < istop; i++, rp += 2)\r
326       {\r
327          png_byte t = *rp;\r
328          *rp = *(rp + 1);\r
329          *(rp + 1) = t;\r
330       }\r
331    }\r
332 }\r
333 #endif\r
334 #endif\r
335 \r
336 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
337 static PNG_CONST png_byte onebppswaptable[256] = {\r
338    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,\r
339    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,\r
340    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,\r
341    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,\r
342    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,\r
343    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,\r
344    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,\r
345    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,\r
346    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,\r
347    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,\r
348    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,\r
349    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,\r
350    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,\r
351    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,\r
352    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,\r
353    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,\r
354    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,\r
355    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,\r
356    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,\r
357    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,\r
358    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,\r
359    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,\r
360    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,\r
361    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,\r
362    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,\r
363    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,\r
364    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,\r
365    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,\r
366    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,\r
367    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,\r
368    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,\r
369    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF\r
370 };\r
371 \r
372 static PNG_CONST png_byte twobppswaptable[256] = {\r
373    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,\r
374    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,\r
375    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,\r
376    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,\r
377    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,\r
378    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,\r
379    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,\r
380    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,\r
381    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,\r
382    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,\r
383    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,\r
384    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,\r
385    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,\r
386    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,\r
387    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,\r
388    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,\r
389    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,\r
390    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,\r
391    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,\r
392    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,\r
393    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,\r
394    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,\r
395    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,\r
396    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,\r
397    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,\r
398    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,\r
399    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,\r
400    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,\r
401    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,\r
402    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,\r
403    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,\r
404    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF\r
405 };\r
406 \r
407 static PNG_CONST png_byte fourbppswaptable[256] = {\r
408    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,\r
409    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,\r
410    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,\r
411    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,\r
412    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,\r
413    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,\r
414    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,\r
415    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,\r
416    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,\r
417    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,\r
418    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,\r
419    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,\r
420    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,\r
421    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,\r
422    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,\r
423    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,\r
424    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,\r
425    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,\r
426    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,\r
427    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,\r
428    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,\r
429    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,\r
430    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,\r
431    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,\r
432    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,\r
433    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,\r
434    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,\r
435    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,\r
436    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,\r
437    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,\r
438    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,\r
439    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF\r
440 };\r
441 \r
442 /* Swaps pixel packing order within bytes */\r
443 void /* PRIVATE */\r
444 png_do_packswap(png_row_infop row_info, png_bytep row)\r
445 {\r
446    png_debug(1, "in png_do_packswap");\r
447 \r
448    if (row_info->bit_depth < 8)\r
449    {\r
450       png_bytep rp;\r
451       png_const_bytep end, table;\r
452 \r
453       end = row + row_info->rowbytes;\r
454 \r
455       if (row_info->bit_depth == 1)\r
456          table = onebppswaptable;\r
457 \r
458       else if (row_info->bit_depth == 2)\r
459          table = twobppswaptable;\r
460 \r
461       else if (row_info->bit_depth == 4)\r
462          table = fourbppswaptable;\r
463 \r
464       else\r
465          return;\r
466 \r
467       for (rp = row; rp < end; rp++)\r
468          *rp = table[*rp];\r
469    }\r
470 }\r
471 #endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */\r
472 \r
473 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \\r
474     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
475 /* Remove a channel - this used to be 'png_do_strip_filler' but it used a\r
476  * somewhat weird combination of flags to determine what to do.  All the calls\r
477  * to png_do_strip_filler are changed in 1.5.2 to call this instead with the\r
478  * correct arguments.\r
479  *\r
480  * The routine isn't general - the channel must be the channel at the start or\r
481  * end (not in the middle) of each pixel.\r
482  */\r
483 void /* PRIVATE */\r
484 png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)\r
485 {\r
486    png_bytep sp = row; /* source pointer */\r
487    png_bytep dp = row; /* destination pointer */\r
488    png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */\r
489 \r
490    /* At the start sp will point to the first byte to copy and dp to where\r
491     * it is copied to.  ep always points just beyond the end of the row, so\r
492     * the loop simply copies (channels-1) channels until sp reaches ep.\r
493     *\r
494     * at_start:        0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.\r
495     *            nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.\r
496     */\r
497 \r
498    /* GA, GX, XG cases */\r
499    if (row_info->channels == 2)\r
500    {\r
501       if (row_info->bit_depth == 8)\r
502       {\r
503          if (at_start) /* Skip initial filler */\r
504             ++sp;\r
505          else          /* Skip initial channel and, for sp, the filler */\r
506             sp += 2, ++dp;\r
507 \r
508          /* For a 1 pixel wide image there is nothing to do */\r
509          while (sp < ep)\r
510             *dp++ = *sp, sp += 2;\r
511 \r
512          row_info->pixel_depth = 8;\r
513       }\r
514 \r
515       else if (row_info->bit_depth == 16)\r
516       {\r
517          if (at_start) /* Skip initial filler */\r
518             sp += 2;\r
519          else          /* Skip initial channel and, for sp, the filler */\r
520             sp += 4, dp += 2;\r
521 \r
522          while (sp < ep)\r
523             *dp++ = *sp++, *dp++ = *sp, sp += 3;\r
524 \r
525          row_info->pixel_depth = 16;\r
526       }\r
527 \r
528       else\r
529          return; /* bad bit depth */\r
530 \r
531       row_info->channels = 1;\r
532 \r
533       /* Finally fix the color type if it records an alpha channel */\r
534       if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)\r
535          row_info->color_type = PNG_COLOR_TYPE_GRAY;\r
536    }\r
537 \r
538    /* RGBA, RGBX, XRGB cases */\r
539    else if (row_info->channels == 4)\r
540    {\r
541       if (row_info->bit_depth == 8)\r
542       {\r
543          if (at_start) /* Skip initial filler */\r
544             ++sp;\r
545          else          /* Skip initial channels and, for sp, the filler */\r
546             sp += 4, dp += 3;\r
547 \r
548          /* Note that the loop adds 3 to dp and 4 to sp each time. */\r
549          while (sp < ep)\r
550             *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;\r
551 \r
552          row_info->pixel_depth = 24;\r
553       }\r
554 \r
555       else if (row_info->bit_depth == 16)\r
556       {\r
557          if (at_start) /* Skip initial filler */\r
558             sp += 2;\r
559          else          /* Skip initial channels and, for sp, the filler */\r
560             sp += 8, dp += 6;\r
561 \r
562          while (sp < ep)\r
563          {\r
564             /* Copy 6 bytes, skip 2 */\r
565             *dp++ = *sp++, *dp++ = *sp++;\r
566             *dp++ = *sp++, *dp++ = *sp++;\r
567             *dp++ = *sp++, *dp++ = *sp, sp += 3;\r
568          }\r
569 \r
570          row_info->pixel_depth = 48;\r
571       }\r
572 \r
573       else\r
574          return; /* bad bit depth */\r
575 \r
576       row_info->channels = 3;\r
577 \r
578       /* Finally fix the color type if it records an alpha channel */\r
579       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
580          row_info->color_type = PNG_COLOR_TYPE_RGB;\r
581    }\r
582 \r
583    else\r
584       return; /* The filler channel has gone already */\r
585 \r
586    /* Fix the rowbytes value. */\r
587    row_info->rowbytes = dp-row;\r
588 }\r
589 #endif\r
590 \r
591 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)\r
592 /* Swaps red and blue bytes within a pixel */\r
593 void /* PRIVATE */\r
594 png_do_bgr(png_row_infop row_info, png_bytep row)\r
595 {\r
596    png_debug(1, "in png_do_bgr");\r
597 \r
598    if ((row_info->color_type & PNG_COLOR_MASK_COLOR))\r
599    {\r
600       png_uint_32 row_width = row_info->width;\r
601       if (row_info->bit_depth == 8)\r
602       {\r
603          if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
604          {\r
605             png_bytep rp;\r
606             png_uint_32 i;\r
607 \r
608             for (i = 0, rp = row; i < row_width; i++, rp += 3)\r
609             {\r
610                png_byte save = *rp;\r
611                *rp = *(rp + 2);\r
612                *(rp + 2) = save;\r
613             }\r
614          }\r
615 \r
616          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
617          {\r
618             png_bytep rp;\r
619             png_uint_32 i;\r
620 \r
621             for (i = 0, rp = row; i < row_width; i++, rp += 4)\r
622             {\r
623                png_byte save = *rp;\r
624                *rp = *(rp + 2);\r
625                *(rp + 2) = save;\r
626             }\r
627          }\r
628       }\r
629 \r
630 #ifdef PNG_16BIT_SUPPORTED\r
631       else if (row_info->bit_depth == 16)\r
632       {\r
633          if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
634          {\r
635             png_bytep rp;\r
636             png_uint_32 i;\r
637 \r
638             for (i = 0, rp = row; i < row_width; i++, rp += 6)\r
639             {\r
640                png_byte save = *rp;\r
641                *rp = *(rp + 4);\r
642                *(rp + 4) = save;\r
643                save = *(rp + 1);\r
644                *(rp + 1) = *(rp + 5);\r
645                *(rp + 5) = save;\r
646             }\r
647          }\r
648 \r
649          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
650          {\r
651             png_bytep rp;\r
652             png_uint_32 i;\r
653 \r
654             for (i = 0, rp = row; i < row_width; i++, rp += 8)\r
655             {\r
656                png_byte save = *rp;\r
657                *rp = *(rp + 4);\r
658                *(rp + 4) = save;\r
659                save = *(rp + 1);\r
660                *(rp + 1) = *(rp + 5);\r
661                *(rp + 5) = save;\r
662             }\r
663          }\r
664       }\r
665 #endif\r
666    }\r
667 }\r
668 #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */\r
669 \r
670 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \\r
671     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)\r
672 /* Added at libpng-1.5.10 */\r
673 void /* PRIVATE */\r
674 png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)\r
675 {\r
676    if (png_ptr->num_palette < (1 << row_info->bit_depth) &&\r
677       png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */\r
678    {\r
679       /* Calculations moved outside switch in an attempt to stop different\r
680        * compiler warnings.  'padding' is in *bits* within the last byte, it is\r
681        * an 'int' because pixel_depth becomes an 'int' in the expression below,\r
682        * and this calculation is used because it avoids warnings that other\r
683        * forms produced on either GCC or MSVC.\r
684        */\r
685       int padding = (-row_info->pixel_depth * row_info->width) & 7;\r
686       png_bytep rp = png_ptr->row_buf + row_info->rowbytes;\r
687 \r
688       switch (row_info->bit_depth)\r
689       {\r
690          case 1:\r
691          {\r
692             /* in this case, all bytes must be 0 so we don't need\r
693              * to unpack the pixels except for the rightmost one.\r
694              */\r
695             for (; rp > png_ptr->row_buf; rp--)\r
696             {\r
697               if (*rp >> padding != 0)\r
698                  png_ptr->num_palette_max = 1;\r
699               padding = 0;\r
700             }\r
701 \r
702             break;\r
703          }\r
704 \r
705          case 2:\r
706          {\r
707             for (; rp > png_ptr->row_buf; rp--)\r
708             {\r
709               int i = ((*rp >> padding) & 0x03);\r
710 \r
711               if (i > png_ptr->num_palette_max)\r
712                  png_ptr->num_palette_max = i;\r
713 \r
714               i = (((*rp >> padding) >> 2) & 0x03);\r
715 \r
716               if (i > png_ptr->num_palette_max)\r
717                  png_ptr->num_palette_max = i;\r
718 \r
719               i = (((*rp >> padding) >> 4) & 0x03);\r
720 \r
721               if (i > png_ptr->num_palette_max)\r
722                  png_ptr->num_palette_max = i;\r
723 \r
724               i = (((*rp >> padding) >> 6) & 0x03);\r
725 \r
726               if (i > png_ptr->num_palette_max)\r
727                  png_ptr->num_palette_max = i;\r
728 \r
729               padding = 0;\r
730             }\r
731 \r
732             break;\r
733          }\r
734 \r
735          case 4:\r
736          {\r
737             for (; rp > png_ptr->row_buf; rp--)\r
738             {\r
739               int i = ((*rp >> padding) & 0x0f);\r
740 \r
741               if (i > png_ptr->num_palette_max)\r
742                  png_ptr->num_palette_max = i;\r
743 \r
744               i = (((*rp >> padding) >> 4) & 0x0f);\r
745 \r
746               if (i > png_ptr->num_palette_max)\r
747                  png_ptr->num_palette_max = i;\r
748 \r
749               padding = 0;\r
750             }\r
751 \r
752             break;\r
753          }\r
754 \r
755          case 8:\r
756          {\r
757             for (; rp > png_ptr->row_buf; rp--)\r
758             {\r
759                if (*rp > png_ptr->num_palette_max)\r
760                   png_ptr->num_palette_max = (int) *rp;\r
761             }\r
762 \r
763             break;\r
764          }\r
765 \r
766          default:\r
767             break;\r
768       }\r
769    }\r
770 }\r
771 #endif /* PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED */\r
772 \r
773 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
774     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)\r
775 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED\r
776 void PNGAPI\r
777 png_set_user_transform_info(png_structrp png_ptr, png_voidp\r
778    user_transform_ptr, int user_transform_depth, int user_transform_channels)\r
779 {\r
780    png_debug(1, "in png_set_user_transform_info");\r
781 \r
782    if (png_ptr == NULL)\r
783       return;\r
784 \r
785 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED\r
786    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&\r
787       (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)\r
788    {\r
789       png_app_error(png_ptr,\r
790             "info change after png_start_read_image or png_read_update_info");\r
791       return;\r
792    }\r
793 #endif\r
794 \r
795    png_ptr->user_transform_ptr = user_transform_ptr;\r
796    png_ptr->user_transform_depth = (png_byte)user_transform_depth;\r
797    png_ptr->user_transform_channels = (png_byte)user_transform_channels;\r
798 }\r
799 #endif\r
800 \r
801 /* This function returns a pointer to the user_transform_ptr associated with\r
802  * the user transform functions.  The application should free any memory\r
803  * associated with this pointer before png_write_destroy and png_read_destroy\r
804  * are called.\r
805  */\r
806 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED\r
807 png_voidp PNGAPI\r
808 png_get_user_transform_ptr(png_const_structrp png_ptr)\r
809 {\r
810    if (png_ptr == NULL)\r
811       return (NULL);\r
812 \r
813    return png_ptr->user_transform_ptr;\r
814 }\r
815 #endif\r
816 \r
817 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED\r
818 png_uint_32 PNGAPI\r
819 png_get_current_row_number(png_const_structrp png_ptr)\r
820 {\r
821    /* See the comments in png.h - this is the sub-image row when reading and\r
822     * interlaced image.\r
823     */\r
824    if (png_ptr != NULL)\r
825       return png_ptr->row_number;\r
826 \r
827    return PNG_UINT_32_MAX; /* help the app not to fail silently */\r
828 }\r
829 \r
830 png_byte PNGAPI\r
831 png_get_current_pass_number(png_const_structrp png_ptr)\r
832 {\r
833    if (png_ptr != NULL)\r
834       return png_ptr->pass;\r
835    return 8; /* invalid */\r
836 }\r
837 #endif /* PNG_USER_TRANSFORM_INFO_SUPPORTED */\r
838 #endif /* PNG_READ_USER_TRANSFORM_SUPPORTED ||\r
839           PNG_WRITE_USER_TRANSFORM_SUPPORTED */\r
840 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r