VirtualBox

source: vbox/trunk/src/libs/libpng-1.6.42/pngtrans.c

Last change on this file was 103316, checked in by vboxsync, 3 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use