Coverage Report

Created: 2024-06-18 06:05

/src/libpng/pngtrans.c
Line
Count
Source (jump to first uncovered 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 */
20
void PNGAPI
21
png_set_bgr(png_structrp png_ptr)
22
0
{
23
0
   png_debug(1, "in png_set_bgr");
24
25
0
   if (png_ptr == NULL)
26
0
      return;
27
28
0
   png_ptr->transformations |= PNG_BGR;
29
0
}
30
#endif
31
32
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
33
/* Turn on 16-bit byte swapping */
34
void PNGAPI
35
png_set_swap(png_structrp png_ptr)
36
0
{
37
0
   png_debug(1, "in png_set_swap");
38
39
0
   if (png_ptr == NULL)
40
0
      return;
41
42
0
   if (png_ptr->bit_depth == 16)
43
0
      png_ptr->transformations |= PNG_SWAP_BYTES;
44
0
}
45
#endif
46
47
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
48
/* Turn on pixel packing */
49
void PNGAPI
50
png_set_packing(png_structrp png_ptr)
51
0
{
52
0
   png_debug(1, "in png_set_packing");
53
54
0
   if (png_ptr == NULL)
55
0
      return;
56
57
0
   if (png_ptr->bit_depth < 8)
58
0
   {
59
0
      png_ptr->transformations |= PNG_PACK;
60
0
#     ifdef PNG_WRITE_SUPPORTED
61
0
         png_ptr->usr_bit_depth = 8;
62
0
#     endif
63
0
   }
64
0
}
65
#endif
66
67
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
68
/* Turn on packed pixel swapping */
69
void PNGAPI
70
png_set_packswap(png_structrp png_ptr)
71
0
{
72
0
   png_debug(1, "in png_set_packswap");
73
74
0
   if (png_ptr == NULL)
75
0
      return;
76
77
0
   if (png_ptr->bit_depth < 8)
78
0
      png_ptr->transformations |= PNG_PACKSWAP;
79
0
}
80
#endif
81
82
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
83
void PNGAPI
84
png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits)
85
0
{
86
0
   png_debug(1, "in png_set_shift");
87
88
0
   if (png_ptr == NULL)
89
0
      return;
90
91
0
   png_ptr->transformations |= PNG_SHIFT;
92
0
   png_ptr->shift = *true_bits;
93
0
}
94
#endif
95
96
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
97
    defined(PNG_WRITE_INTERLACING_SUPPORTED)
98
int PNGAPI
99
png_set_interlace_handling(png_structrp png_ptr)
100
0
{
101
0
   png_debug(1, "in png_set_interlace handling");
102
103
0
   if (png_ptr != 0 && png_ptr->interlaced != 0)
104
0
   {
105
0
      png_ptr->transformations |= PNG_INTERLACE;
106
0
      return 7;
107
0
   }
108
109
0
   return 1;
110
0
}
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
 */
119
void PNGAPI
120
png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
121
0
{
122
0
   png_debug(1, "in png_set_filler");
123
124
0
   if (png_ptr == NULL)
125
0
      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
0
   if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
131
0
   {
132
0
#     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
0
         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
0
   }
148
149
0
   else /* write */
150
0
   {
151
0
#     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
0
         switch (png_ptr->color_type)
156
0
         {
157
0
            case PNG_COLOR_TYPE_RGB:
158
0
               png_ptr->usr_channels = 4;
159
0
               break;
160
161
0
            case PNG_COLOR_TYPE_GRAY:
162
0
               if (png_ptr->bit_depth >= 8)
163
0
               {
164
0
                  png_ptr->usr_channels = 2;
165
0
                  break;
166
0
               }
167
168
0
               else
169
0
               {
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
0
                  png_app_error(png_ptr,
175
0
                      "png_set_filler is invalid for"
176
0
                      " low bit depth gray output");
177
0
                  return;
178
0
               }
179
180
0
            default:
181
0
               png_app_error(png_ptr,
182
0
                   "png_set_filler: inappropriate color type");
183
0
               return;
184
0
         }
185
#     else
186
         png_app_error(png_ptr, "png_set_filler not supported on write");
187
         return;
188
#     endif
189
0
   }
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
0
   png_ptr->transformations |= PNG_FILLER;
195
196
0
   if (filler_loc == PNG_FILLER_AFTER)
197
0
      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
198
199
0
   else
200
0
      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
201
0
}
202
203
/* Added to libpng-1.2.7 */
204
void PNGAPI
205
png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
206
0
{
207
0
   png_debug(1, "in png_set_add_alpha");
208
209
0
   if (png_ptr == NULL)
210
0
      return;
211
212
0
   png_set_filler(png_ptr, filler, filler_loc);
213
   /* The above may fail to do anything. */
214
0
   if ((png_ptr->transformations & PNG_FILLER) != 0)
215
0
      png_ptr->transformations |= PNG_ADD_ALPHA;
216
0
}
217
218
#endif
219
220
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
221
    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
222
void PNGAPI
223
png_set_swap_alpha(png_structrp png_ptr)
224
0
{
225
0
   png_debug(1, "in png_set_swap_alpha");
226
227
0
   if (png_ptr == NULL)
228
0
      return;
229
230
0
   png_ptr->transformations |= PNG_SWAP_ALPHA;
231
0
}
232
#endif
233
234
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
235
    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
236
void PNGAPI
237
png_set_invert_alpha(png_structrp png_ptr)
238
0
{
239
0
   png_debug(1, "in png_set_invert_alpha");
240
241
0
   if (png_ptr == NULL)
242
0
      return;
243
244
0
   png_ptr->transformations |= PNG_INVERT_ALPHA;
245
0
}
246
#endif
247
248
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
249
void PNGAPI
250
png_set_invert_mono(png_structrp png_ptr)
251
0
{
252
0
   png_debug(1, "in png_set_invert_mono");
253
254
0
   if (png_ptr == NULL)
255
0
      return;
256
257
0
   png_ptr->transformations |= PNG_INVERT_MONO;
258
0
}
259
260
/* Invert monochrome grayscale data */
261
void /* PRIVATE */
262
png_do_invert(png_row_infop row_info, png_bytep row)
263
0
{
264
0
   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
0
   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
270
0
   {
271
0
      png_bytep rp = row;
272
0
      size_t i;
273
0
      size_t istop = row_info->rowbytes;
274
275
0
      for (i = 0; i < istop; i++)
276
0
      {
277
0
         *rp = (png_byte)(~(*rp));
278
0
         rp++;
279
0
      }
280
0
   }
281
282
0
   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
283
0
      row_info->bit_depth == 8)
284
0
   {
285
0
      png_bytep rp = row;
286
0
      size_t i;
287
0
      size_t istop = row_info->rowbytes;
288
289
0
      for (i = 0; i < istop; i += 2)
290
0
      {
291
0
         *rp = (png_byte)(~(*rp));
292
0
         rp += 2;
293
0
      }
294
0
   }
295
296
0
#ifdef PNG_16BIT_SUPPORTED
297
0
   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
298
0
      row_info->bit_depth == 16)
299
0
   {
300
0
      png_bytep rp = row;
301
0
      size_t i;
302
0
      size_t istop = row_info->rowbytes;
303
304
0
      for (i = 0; i < istop; i += 4)
305
0
      {
306
0
         *rp = (png_byte)(~(*rp));
307
0
         *(rp + 1) = (png_byte)(~(*(rp + 1)));
308
0
         rp += 4;
309
0
      }
310
0
   }
311
0
#endif
312
0
}
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 */
318
void /* PRIVATE */
319
png_do_swap(png_row_infop row_info, png_bytep row)
320
0
{
321
0
   png_debug(1, "in png_do_swap");
322
323
0
   if (row_info->bit_depth == 16)
324
0
   {
325
0
      png_bytep rp = row;
326
0
      png_uint_32 i;
327
0
      png_uint_32 istop= row_info->width * row_info->channels;
328
329
0
      for (i = 0; i < istop; i++, rp += 2)
330
0
      {
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
0
         png_byte t = *rp;
338
0
         *rp = *(rp + 1);
339
0
         *(rp + 1) = t;
340
0
#endif
341
0
      }
342
0
   }
343
0
}
344
#endif
345
#endif
346
347
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
348
static 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
383
static 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
418
static 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 */
454
void /* PRIVATE */
455
png_do_packswap(png_row_infop row_info, png_bytep row)
456
0
{
457
0
   png_debug(1, "in png_do_packswap");
458
459
0
   if (row_info->bit_depth < 8)
460
0
   {
461
0
      png_bytep rp;
462
0
      png_const_bytep end, table;
463
464
0
      end = row + row_info->rowbytes;
465
466
0
      if (row_info->bit_depth == 1)
467
0
         table = onebppswaptable;
468
469
0
      else if (row_info->bit_depth == 2)
470
0
         table = twobppswaptable;
471
472
0
      else if (row_info->bit_depth == 4)
473
0
         table = fourbppswaptable;
474
475
0
      else
476
0
         return;
477
478
0
      for (rp = row; rp < end; rp++)
479
0
         *rp = table[*rp];
480
0
   }
481
0
}
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
 */
494
void /* PRIVATE */
495
png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
496
0
{
497
0
   png_bytep sp = row; /* source pointer */
498
0
   png_bytep dp = row; /* destination pointer */
499
0
   png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
500
501
0
   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
0
   if (row_info->channels == 2)
513
0
   {
514
0
      if (row_info->bit_depth == 8)
515
0
      {
516
0
         if (at_start != 0) /* Skip initial filler */
517
0
            ++sp;
518
0
         else          /* Skip initial channel and, for sp, the filler */
519
0
         {
520
0
            sp += 2; ++dp;
521
0
         }
522
523
         /* For a 1 pixel wide image there is nothing to do */
524
0
         while (sp < ep)
525
0
         {
526
0
            *dp++ = *sp; sp += 2;
527
0
         }
528
529
0
         row_info->pixel_depth = 8;
530
0
      }
531
532
0
      else if (row_info->bit_depth == 16)
533
0
      {
534
0
         if (at_start != 0) /* Skip initial filler */
535
0
            sp += 2;
536
0
         else          /* Skip initial channel and, for sp, the filler */
537
0
         {
538
0
            sp += 4; dp += 2;
539
0
         }
540
541
0
         while (sp < ep)
542
0
         {
543
0
            *dp++ = *sp++; *dp++ = *sp; sp += 3;
544
0
         }
545
546
0
         row_info->pixel_depth = 16;
547
0
      }
548
549
0
      else
550
0
         return; /* bad bit depth */
551
552
0
      row_info->channels = 1;
553
554
      /* Finally fix the color type if it records an alpha channel */
555
0
      if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
556
0
         row_info->color_type = PNG_COLOR_TYPE_GRAY;
557
0
   }
558
559
   /* RGBA, RGBX, XRGB cases */
560
0
   else if (row_info->channels == 4)
561
0
   {
562
0
      if (row_info->bit_depth == 8)
563
0
      {
564
0
         if (at_start != 0) /* Skip initial filler */
565
0
            ++sp;
566
0
         else          /* Skip initial channels and, for sp, the filler */
567
0
         {
568
0
            sp += 4; dp += 3;
569
0
         }
570
571
         /* Note that the loop adds 3 to dp and 4 to sp each time. */
572
0
         while (sp < ep)
573
0
         {
574
0
            *dp++ = *sp++; *dp++ = *sp++; *dp++ = *sp; sp += 2;
575
0
         }
576
577
0
         row_info->pixel_depth = 24;
578
0
      }
579
580
0
      else if (row_info->bit_depth == 16)
581
0
      {
582
0
         if (at_start != 0) /* Skip initial filler */
583
0
            sp += 2;
584
0
         else          /* Skip initial channels and, for sp, the filler */
585
0
         {
586
0
            sp += 8; dp += 6;
587
0
         }
588
589
0
         while (sp < ep)
590
0
         {
591
            /* Copy 6 bytes, skip 2 */
592
0
            *dp++ = *sp++; *dp++ = *sp++;
593
0
            *dp++ = *sp++; *dp++ = *sp++;
594
0
            *dp++ = *sp++; *dp++ = *sp; sp += 3;
595
0
         }
596
597
0
         row_info->pixel_depth = 48;
598
0
      }
599
600
0
      else
601
0
         return; /* bad bit depth */
602
603
0
      row_info->channels = 3;
604
605
      /* Finally fix the color type if it records an alpha channel */
606
0
      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
607
0
         row_info->color_type = PNG_COLOR_TYPE_RGB;
608
0
   }
609
610
0
   else
611
0
      return; /* The filler channel has gone already */
612
613
   /* Fix the rowbytes value. */
614
0
   row_info->rowbytes = (size_t)(dp-row);
615
0
}
616
#endif
617
618
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
619
/* Swaps red and blue bytes within a pixel */
620
void /* PRIVATE */
621
png_do_bgr(png_row_infop row_info, png_bytep row)
622
0
{
623
0
   png_debug(1, "in png_do_bgr");
624
625
0
   if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
626
0
   {
627
0
      png_uint_32 row_width = row_info->width;
628
0
      if (row_info->bit_depth == 8)
629
0
      {
630
0
         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
631
0
         {
632
0
            png_bytep rp;
633
0
            png_uint_32 i;
634
635
0
            for (i = 0, rp = row; i < row_width; i++, rp += 3)
636
0
            {
637
0
               png_byte save = *rp;
638
0
               *rp = *(rp + 2);
639
0
               *(rp + 2) = save;
640
0
            }
641
0
         }
642
643
0
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
644
0
         {
645
0
            png_bytep rp;
646
0
            png_uint_32 i;
647
648
0
            for (i = 0, rp = row; i < row_width; i++, rp += 4)
649
0
            {
650
0
               png_byte save = *rp;
651
0
               *rp = *(rp + 2);
652
0
               *(rp + 2) = save;
653
0
            }
654
0
         }
655
0
      }
656
657
0
#ifdef PNG_16BIT_SUPPORTED
658
0
      else if (row_info->bit_depth == 16)
659
0
      {
660
0
         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
661
0
         {
662
0
            png_bytep rp;
663
0
            png_uint_32 i;
664
665
0
            for (i = 0, rp = row; i < row_width; i++, rp += 6)
666
0
            {
667
0
               png_byte save = *rp;
668
0
               *rp = *(rp + 4);
669
0
               *(rp + 4) = save;
670
0
               save = *(rp + 1);
671
0
               *(rp + 1) = *(rp + 5);
672
0
               *(rp + 5) = save;
673
0
            }
674
0
         }
675
676
0
         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
677
0
         {
678
0
            png_bytep rp;
679
0
            png_uint_32 i;
680
681
0
            for (i = 0, rp = row; i < row_width; i++, rp += 8)
682
0
            {
683
0
               png_byte save = *rp;
684
0
               *rp = *(rp + 4);
685
0
               *(rp + 4) = save;
686
0
               save = *(rp + 1);
687
0
               *(rp + 1) = *(rp + 5);
688
0
               *(rp + 5) = save;
689
0
            }
690
0
         }
691
0
      }
692
0
#endif
693
0
   }
694
0
}
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 */
700
void /* PRIVATE */
701
png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
702
0
{
703
0
   png_debug(1, "in png_do_check_palette_indexes");
704
705
0
   if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
706
0
      png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
707
0
   {
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
0
      int padding = PNG_PADBITS(row_info->pixel_depth, row_info->width);
715
0
      png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
716
717
0
      switch (row_info->bit_depth)
718
0
      {
719
0
         case 1:
720
0
         {
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
0
            for (; rp > png_ptr->row_buf; rp--)
725
0
            {
726
0
              if ((*rp >> padding) != 0)
727
0
                 png_ptr->num_palette_max = 1;
728
0
              padding = 0;
729
0
            }
730
731
0
            break;
732
0
         }
733
734
0
         case 2:
735
0
         {
736
0
            for (; rp > png_ptr->row_buf; rp--)
737
0
            {
738
0
              int i = ((*rp >> padding) & 0x03);
739
740
0
              if (i > png_ptr->num_palette_max)
741
0
                 png_ptr->num_palette_max = i;
742
743
0
              i = (((*rp >> padding) >> 2) & 0x03);
744
745
0
              if (i > png_ptr->num_palette_max)
746
0
                 png_ptr->num_palette_max = i;
747
748
0
              i = (((*rp >> padding) >> 4) & 0x03);
749
750
0
              if (i > png_ptr->num_palette_max)
751
0
                 png_ptr->num_palette_max = i;
752
753
0
              i = (((*rp >> padding) >> 6) & 0x03);
754
755
0
              if (i > png_ptr->num_palette_max)
756
0
                 png_ptr->num_palette_max = i;
757
758
0
              padding = 0;
759
0
            }
760
761
0
            break;
762
0
         }
763
764
0
         case 4:
765
0
         {
766
0
            for (; rp > png_ptr->row_buf; rp--)
767
0
            {
768
0
              int i = ((*rp >> padding) & 0x0f);
769
770
0
              if (i > png_ptr->num_palette_max)
771
0
                 png_ptr->num_palette_max = i;
772
773
0
              i = (((*rp >> padding) >> 4) & 0x0f);
774
775
0
              if (i > png_ptr->num_palette_max)
776
0
                 png_ptr->num_palette_max = i;
777
778
0
              padding = 0;
779
0
            }
780
781
0
            break;
782
0
         }
783
784
0
         case 8:
785
0
         {
786
0
            for (; rp > png_ptr->row_buf; rp--)
787
0
            {
788
0
               if (*rp > png_ptr->num_palette_max)
789
0
                  png_ptr->num_palette_max = (int) *rp;
790
0
            }
791
792
0
            break;
793
0
         }
794
795
0
         default:
796
0
            break;
797
0
      }
798
0
   }
799
0
}
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
805
void PNGAPI
806
png_set_user_transform_info(png_structrp png_ptr, png_voidp
807
   user_transform_ptr, int user_transform_depth, int user_transform_channels)
808
0
{
809
0
   png_debug(1, "in png_set_user_transform_info");
810
811
0
   if (png_ptr == NULL)
812
0
      return;
813
814
0
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
815
0
   if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
816
0
      (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
817
0
   {
818
0
      png_app_error(png_ptr,
819
0
          "info change after png_start_read_image or png_read_update_info");
820
0
      return;
821
0
   }
822
0
#endif
823
824
0
   png_ptr->user_transform_ptr = user_transform_ptr;
825
0
   png_ptr->user_transform_depth = (png_byte)user_transform_depth;
826
0
   png_ptr->user_transform_channels = (png_byte)user_transform_channels;
827
0
}
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
836
png_voidp PNGAPI
837
png_get_user_transform_ptr(png_const_structrp png_ptr)
838
0
{
839
0
   if (png_ptr == NULL)
840
0
      return NULL;
841
842
0
   return png_ptr->user_transform_ptr;
843
0
}
844
#endif
845
846
#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
847
png_uint_32 PNGAPI
848
png_get_current_row_number(png_const_structrp png_ptr)
849
0
{
850
   /* See the comments in png.h - this is the sub-image row when reading an
851
    * interlaced image.
852
    */
853
0
   if (png_ptr != NULL)
854
0
      return png_ptr->row_number;
855
856
0
   return PNG_UINT_32_MAX; /* help the app not to fail silently */
857
0
}
858
859
png_byte PNGAPI
860
png_get_current_pass_number(png_const_structrp png_ptr)
861
0
{
862
0
   if (png_ptr != NULL)
863
0
      return png_ptr->pass;
864
0
   return 8; /* invalid */
865
0
}
866
#endif /* USER_TRANSFORM_INFO */
867
#endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
868
#endif /* READ || WRITE */