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