source: bootcd/isolinux/syslinux-6.03/com32/lib/libpng/pngtrans.c

Last change on this file was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago

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