Prusa MINI Firmware overview
Classes | Macros | Typedefs | Functions
pngrtran.c File Reference
#include "pngpriv.h"

Classes

struct  png_dsort_struct
 

Macros

#define CHOP(x)   (x)=((png_uint_16)PNG_DIV257(x))
 

Typedefs

typedef struct png_dsort_struct png_dsort
 
typedef png_dsort * png_dsortp
 
typedef png_dsort ** png_dsortpp
 

Functions

void PNGAPI png_set_crc_action (png_structrp png_ptr, int crit_action, int ancil_action)
 
static int png_rtran_ok (png_structrp png_ptr, int need_IHDR)
 
void PNGFAPI png_set_background_fixed (png_structrp png_ptr, png_const_color_16p background_color, int background_gamma_code, int need_expand, png_fixed_point background_gamma)
 
void PNGAPI png_set_background (png_structrp png_ptr, png_const_color_16p background_color, int background_gamma_code, int need_expand, double background_gamma)
 
void PNGAPI png_set_scale_16 (png_structrp png_ptr)
 
void PNGAPI png_set_strip_16 (png_structrp png_ptr)
 
void PNGAPI png_set_strip_alpha (png_structrp png_ptr)
 
static png_fixed_point translate_gamma_flags (png_structrp png_ptr, png_fixed_point output_gamma, int is_screen)
 
static png_fixed_point convert_gamma_value (png_structrp png_ptr, double output_gamma)
 
void PNGFAPI png_set_alpha_mode_fixed (png_structrp png_ptr, int mode, png_fixed_point output_gamma)
 
void PNGAPI png_set_alpha_mode (png_structrp png_ptr, int mode, double output_gamma)
 
void PNGAPI png_set_quantize (png_structrp png_ptr, png_colorp palette, int num_palette, int maximum_colors, png_const_uint_16p histogram, int full_quantize)
 
void PNGFAPI png_set_gamma_fixed (png_structrp png_ptr, png_fixed_point scrn_gamma, png_fixed_point file_gamma)
 
void PNGAPI png_set_gamma (png_structrp png_ptr, double scrn_gamma, double file_gamma)
 
void PNGAPI png_set_expand (png_structrp png_ptr)
 
void PNGAPI png_set_palette_to_rgb (png_structrp png_ptr)
 
void PNGAPI png_set_expand_gray_1_2_4_to_8 (png_structrp png_ptr)
 
void PNGAPI png_set_tRNS_to_alpha (png_structrp png_ptr)
 
void PNGAPI png_set_expand_16 (png_structrp png_ptr)
 
void PNGAPI png_set_gray_to_rgb (png_structrp png_ptr)
 
void PNGFAPI png_set_rgb_to_gray_fixed (png_structrp png_ptr, int error_action, png_fixed_point red, png_fixed_point green)
 
void PNGAPI png_set_rgb_to_gray (png_structrp png_ptr, int error_action, double red, double green)
 
void PNGAPI png_set_read_user_transform_fn (png_structrp png_ptr, png_user_transform_ptr read_user_transform_fn)
 
static int png_gamma_threshold (png_fixed_point screen_gamma, png_fixed_point file_gamma)
 
static void png_init_palette_transformations (png_structrp png_ptr)
 
static void png_init_rgb_transformations (png_structrp png_ptr)
 
void png_init_read_transformations (png_structrp png_ptr)
 
void png_read_transform_info (png_structrp png_ptr, png_inforp info_ptr)
 
static void png_do_unpack (png_row_infop row_info, png_bytep row)
 
static void png_do_unshift (png_row_infop row_info, png_bytep row, png_const_color_8p sig_bits)
 
static void png_do_scale_16_to_8 (png_row_infop row_info, png_bytep row)
 
static void png_do_chop (png_row_infop row_info, png_bytep row)
 
static void png_do_read_swap_alpha (png_row_infop row_info, png_bytep row)
 
static void png_do_read_invert_alpha (png_row_infop row_info, png_bytep row)
 
static void png_do_read_filler (png_row_infop row_info, png_bytep row, png_uint_32 filler, png_uint_32 flags)
 
static void png_do_gray_to_rgb (png_row_infop row_info, png_bytep row)
 
static int png_do_rgb_to_gray (png_structrp png_ptr, png_row_infop row_info, png_bytep row)
 
static void png_do_compose (png_row_infop row_info, png_bytep row, png_structrp png_ptr)
 
static void png_do_gamma (png_row_infop row_info, png_bytep row, png_structrp png_ptr)
 
static void png_do_encode_alpha (png_row_infop row_info, png_bytep row, png_structrp png_ptr)
 
static void png_do_expand_palette (png_structrp png_ptr, png_row_infop row_info, png_bytep row, png_const_colorp palette, png_const_bytep trans_alpha, int num_trans)
 
static void png_do_expand (png_row_infop row_info, png_bytep row, png_const_color_16p trans_color)
 
static void png_do_expand_16 (png_row_infop row_info, png_bytep row)
 
static void png_do_quantize (png_row_infop row_info, png_bytep row, png_const_bytep palette_lookup, png_const_bytep quantize_lookup)
 
void png_do_read_transformations (png_structrp png_ptr, png_row_infop row_info)
 

Macro Definition Documentation

◆ CHOP

#define CHOP (   x)    (x)=((png_uint_16)PNG_DIV257(x))

Typedef Documentation

◆ png_dsort

typedef struct png_dsort_struct png_dsort

◆ png_dsortp

typedef png_dsort* png_dsortp

◆ png_dsortpp

typedef png_dsort* * png_dsortpp

Function Documentation

◆ png_set_crc_action()

void PNGAPI png_set_crc_action ( png_structrp  png_ptr,
int  crit_action,
int  ancil_action 
)
37 {
38  png_debug(1, "in png_set_crc_action");
39 
40  if (png_ptr == NULL)
41  return;
42 
43  /* Tell libpng how we react to CRC errors in critical chunks */
44  switch (crit_action)
45  {
46  case PNG_CRC_NO_CHANGE: /* Leave setting as is */
47  break;
48 
49  case PNG_CRC_WARN_USE: /* Warn/use data */
50  png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
51  png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
52  break;
53 
54  case PNG_CRC_QUIET_USE: /* Quiet/use data */
55  png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
56  png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
57  PNG_FLAG_CRC_CRITICAL_IGNORE;
58  break;
59 
60  case PNG_CRC_WARN_DISCARD: /* Not a valid action for critical data */
61  png_warning(png_ptr,
62  "Can't discard critical data on CRC error");
63  /* FALLTHROUGH */
64  case PNG_CRC_ERROR_QUIT: /* Error/quit */
65 
66  case PNG_CRC_DEFAULT:
67  default:
68  png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
69  break;
70  }
71 
72  /* Tell libpng how we react to CRC errors in ancillary chunks */
73  switch (ancil_action)
74  {
75  case PNG_CRC_NO_CHANGE: /* Leave setting as is */
76  break;
77 
78  case PNG_CRC_WARN_USE: /* Warn/use data */
79  png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
80  png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
81  break;
82 
83  case PNG_CRC_QUIET_USE: /* Quiet/use data */
84  png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
85  png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
86  PNG_FLAG_CRC_ANCILLARY_NOWARN;
87  break;
88 
89  case PNG_CRC_ERROR_QUIT: /* Error/quit */
90  png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
91  png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
92  break;
93 
94  case PNG_CRC_WARN_DISCARD: /* Warn/discard data */
95 
96  case PNG_CRC_DEFAULT:
97  default:
98  png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
99  break;
100  }
101 }
Here is the call graph for this function:

◆ png_rtran_ok()

static int png_rtran_ok ( png_structrp  png_ptr,
int  need_IHDR 
)
static
111 {
112  if (png_ptr != NULL)
113  {
114  if ((png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
115  png_app_error(png_ptr,
116  "invalid after png_start_read_image or png_read_update_info");
117 
118  else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0)
119  png_app_error(png_ptr, "invalid before the PNG header has been read");
120 
121  else
122  {
123  /* Turn on failure to initialize correctly for all transforms. */
124  png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED;
125 
126  return 1; /* Ok */
127  }
128  }
129 
130  return 0; /* no png_error possible! */
131 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_background_fixed()

void PNGFAPI png_set_background_fixed ( png_structrp  png_ptr,
png_const_color_16p  background_color,
int  background_gamma_code,
int  need_expand,
png_fixed_point  background_gamma 
)
140 {
141  png_debug(1, "in png_set_background_fixed");
142 
143  if (png_rtran_ok(png_ptr, 0) == 0 || background_color == NULL)
144  return;
145 
146  if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
147  {
148  png_warning(png_ptr, "Application must supply a known background gamma");
149  return;
150  }
151 
152  png_ptr->transformations |= PNG_COMPOSE | PNG_STRIP_ALPHA;
153  png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
154  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
155 
156  png_ptr->background = *background_color;
157  png_ptr->background_gamma = background_gamma;
158  png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
159  if (need_expand != 0)
160  png_ptr->transformations |= PNG_BACKGROUND_EXPAND;
161  else
162  png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
163 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_background()

void PNGAPI png_set_background ( png_structrp  png_ptr,
png_const_color_16p  background_color,
int  background_gamma_code,
int  need_expand,
double  background_gamma 
)
170 {
171  png_set_background_fixed(png_ptr, background_color, background_gamma_code,
172  need_expand, png_fixed(png_ptr, background_gamma, "png_set_background"));
173 }
Here is the call graph for this function:

◆ png_set_scale_16()

void PNGAPI png_set_scale_16 ( png_structrp  png_ptr)
184 {
185  png_debug(1, "in png_set_scale_16");
186 
187  if (png_rtran_ok(png_ptr, 0) == 0)
188  return;
189 
190  png_ptr->transformations |= PNG_SCALE_16_TO_8;
191 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_strip_16()

void PNGAPI png_set_strip_16 ( png_structrp  png_ptr)
198 {
199  png_debug(1, "in png_set_strip_16");
200 
201  if (png_rtran_ok(png_ptr, 0) == 0)
202  return;
203 
204  png_ptr->transformations |= PNG_16_TO_8;
205 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_strip_alpha()

void PNGAPI png_set_strip_alpha ( png_structrp  png_ptr)
211 {
212  png_debug(1, "in png_set_strip_alpha");
213 
214  if (png_rtran_ok(png_ptr, 0) == 0)
215  return;
216 
217  png_ptr->transformations |= PNG_STRIP_ALPHA;
218 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ translate_gamma_flags()

static png_fixed_point translate_gamma_flags ( png_structrp  png_ptr,
png_fixed_point  output_gamma,
int  is_screen 
)
static
225 {
226  /* Check for flag values. The main reason for having the old Mac value as a
227  * flag is that it is pretty near impossible to work out what the correct
228  * value is from Apple documentation - a working Mac system is needed to
229  * discover the value!
230  */
231  if (output_gamma == PNG_DEFAULT_sRGB ||
232  output_gamma == PNG_FP_1 / PNG_DEFAULT_sRGB)
233  {
234  /* If there is no sRGB support this just sets the gamma to the standard
235  * sRGB value. (This is a side effect of using this function!)
236  */
237 # ifdef PNG_READ_sRGB_SUPPORTED
238  png_ptr->flags |= PNG_FLAG_ASSUME_sRGB;
239 # else
240  PNG_UNUSED(png_ptr)
241 # endif
242  if (is_screen != 0)
243  output_gamma = PNG_GAMMA_sRGB;
244  else
245  output_gamma = PNG_GAMMA_sRGB_INVERSE;
246  }
247 
248  else if (output_gamma == PNG_GAMMA_MAC_18 ||
249  output_gamma == PNG_FP_1 / PNG_GAMMA_MAC_18)
250  {
251  if (is_screen != 0)
252  output_gamma = PNG_GAMMA_MAC_OLD;
253  else
254  output_gamma = PNG_GAMMA_MAC_INVERSE;
255  }
256 
257  return output_gamma;
258 }
Here is the caller graph for this function:

◆ convert_gamma_value()

static png_fixed_point convert_gamma_value ( png_structrp  png_ptr,
double  output_gamma 
)
static
263 {
264  /* The following silently ignores cases where fixed point (times 100,000)
265  * gamma values are passed to the floating point API. This is safe and it
266  * means the fixed point constants work just fine with the floating point
267  * API. The alternative would just lead to undetected errors and spurious
268  * bug reports. Negative values fail inside the _fixed API unless they
269  * correspond to the flag values.
270  */
271  if (output_gamma > 0 && output_gamma < 128)
272  output_gamma *= PNG_FP_1;
273 
274  /* This preserves -1 and -2 exactly: */
275  output_gamma = floor(output_gamma + .5);
276 
277  if (output_gamma > PNG_FP_MAX || output_gamma < PNG_FP_MIN)
278  png_fixed_error(png_ptr, "gamma value");
279 
280  return (png_fixed_point)output_gamma;
281 }
Here is the caller graph for this function:

◆ png_set_alpha_mode_fixed()

void PNGFAPI png_set_alpha_mode_fixed ( png_structrp  png_ptr,
int  mode,
png_fixed_point  output_gamma 
)
289 {
290  int compose = 0;
291  png_fixed_point file_gamma;
292 
293  png_debug(1, "in png_set_alpha_mode");
294 
295  if (png_rtran_ok(png_ptr, 0) == 0)
296  return;
297 
298  output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/);
299 
300  /* Validate the value to ensure it is in a reasonable range. The value
301  * is expected to be 1 or greater, but this range test allows for some
302  * viewing correction values. The intent is to weed out users of this API
303  * who use the inverse of the gamma value accidentally! Since some of these
304  * values are reasonable this may have to be changed:
305  *
306  * 1.6.x: changed from 0.07..3 to 0.01..100 (to accommodate the optimal 16-bit
307  * gamma of 36, and its reciprocal.)
308  */
309  if (output_gamma < 1000 || output_gamma > 10000000)
310  png_error(png_ptr, "output gamma out of expected range");
311 
312  /* The default file gamma is the inverse of the output gamma; the output
313  * gamma may be changed below so get the file value first:
314  */
315  file_gamma = png_reciprocal(output_gamma);
316 
317  /* There are really 8 possibilities here, composed of any combination
318  * of:
319  *
320  * premultiply the color channels
321  * do not encode non-opaque pixels
322  * encode the alpha as well as the color channels
323  *
324  * The differences disappear if the input/output ('screen') gamma is 1.0,
325  * because then the encoding is a no-op and there is only the choice of
326  * premultiplying the color channels or not.
327  *
328  * png_set_alpha_mode and png_set_background interact because both use
329  * png_compose to do the work. Calling both is only useful when
330  * png_set_alpha_mode is used to set the default mode - PNG_ALPHA_PNG - along
331  * with a default gamma value. Otherwise PNG_COMPOSE must not be set.
332  */
333  switch (mode)
334  {
335  case PNG_ALPHA_PNG: /* default: png standard */
336  /* No compose, but it may be set by png_set_background! */
337  png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
338  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
339  break;
340 
341  case PNG_ALPHA_ASSOCIATED: /* color channels premultiplied */
342  compose = 1;
343  png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
344  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
345  /* The output is linear: */
346  output_gamma = PNG_FP_1;
347  break;
348 
349  case PNG_ALPHA_OPTIMIZED: /* associated, non-opaque pixels linear */
350  compose = 1;
351  png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
352  png_ptr->flags |= PNG_FLAG_OPTIMIZE_ALPHA;
353  /* output_gamma records the encoding of opaque pixels! */
354  break;
355 
356  case PNG_ALPHA_BROKEN: /* associated, non-linear, alpha encoded */
357  compose = 1;
358  png_ptr->transformations |= PNG_ENCODE_ALPHA;
359  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
360  break;
361 
362  default:
363  png_error(png_ptr, "invalid alpha mode");
364  }
365 
366  /* Only set the default gamma if the file gamma has not been set (this has
367  * the side effect that the gamma in a second call to png_set_alpha_mode will
368  * be ignored.)
369  */
370  if (png_ptr->colorspace.gamma == 0)
371  {
372  png_ptr->colorspace.gamma = file_gamma;
373  png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
374  }
375 
376  /* But always set the output gamma: */
377  png_ptr->screen_gamma = output_gamma;
378 
379  /* Finally, if pre-multiplying, set the background fields to achieve the
380  * desired result.
381  */
382  if (compose != 0)
383  {
384  /* And obtain alpha pre-multiplication by composing on black: */
385  memset(&png_ptr->background, 0, (sizeof png_ptr->background));
386  png_ptr->background_gamma = png_ptr->colorspace.gamma; /* just in case */
387  png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE;
388  png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
389 
390  if ((png_ptr->transformations & PNG_COMPOSE) != 0)
391  png_error(png_ptr,
392  "conflicting calls to set alpha mode and background");
393 
394  png_ptr->transformations |= PNG_COMPOSE;
395  }
396 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_alpha_mode()

void PNGAPI png_set_alpha_mode ( png_structrp  png_ptr,
int  mode,
double  output_gamma 
)
401 {
402  png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr,
403  output_gamma));
404 }
Here is the call graph for this function:

◆ png_set_quantize()

void PNGAPI png_set_quantize ( png_structrp  png_ptr,
png_colorp  palette,
int  num_palette,
int  maximum_colors,
png_const_uint_16p  histogram,
int  full_quantize 
)
431 {
432  png_debug(1, "in png_set_quantize");
433 
434  if (png_rtran_ok(png_ptr, 0) == 0)
435  return;
436 
437  png_ptr->transformations |= PNG_QUANTIZE;
438 
439  if (full_quantize == 0)
440  {
441  int i;
442 
443  png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr,
444  (png_alloc_size_t)((png_uint_32)num_palette * (sizeof (png_byte))));
445  for (i = 0; i < num_palette; i++)
446  png_ptr->quantize_index[i] = (png_byte)i;
447  }
448 
449  if (num_palette > maximum_colors)
450  {
451  if (histogram != NULL)
452  {
453  /* This is easy enough, just throw out the least used colors.
454  * Perhaps not the best solution, but good enough.
455  */
456 
457  int i;
458 
459  /* Initialize an array to sort colors */
460  png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr,
461  (png_alloc_size_t)((png_uint_32)num_palette * (sizeof (png_byte))));
462 
463  /* Initialize the quantize_sort array */
464  for (i = 0; i < num_palette; i++)
465  png_ptr->quantize_sort[i] = (png_byte)i;
466 
467  /* Find the least used palette entries by starting a
468  * bubble sort, and running it until we have sorted
469  * out enough colors. Note that we don't care about
470  * sorting all the colors, just finding which are
471  * least used.
472  */
473 
474  for (i = num_palette - 1; i >= maximum_colors; i--)
475  {
476  int done; /* To stop early if the list is pre-sorted */
477  int j;
478 
479  done = 1;
480  for (j = 0; j < i; j++)
481  {
482  if (histogram[png_ptr->quantize_sort[j]]
483  < histogram[png_ptr->quantize_sort[j + 1]])
484  {
485  png_byte t;
486 
487  t = png_ptr->quantize_sort[j];
488  png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1];
489  png_ptr->quantize_sort[j + 1] = t;
490  done = 0;
491  }
492  }
493 
494  if (done != 0)
495  break;
496  }
497 
498  /* Swap the palette around, and set up a table, if necessary */
499  if (full_quantize != 0)
500  {
501  int j = num_palette;
502 
503  /* Put all the useful colors within the max, but don't
504  * move the others.
505  */
506  for (i = 0; i < maximum_colors; i++)
507  {
508  if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
509  {
510  do
511  j--;
512  while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
513 
514  palette[i] = palette[j];
515  }
516  }
517  }
518  else
519  {
520  int j = num_palette;
521 
522  /* Move all the used colors inside the max limit, and
523  * develop a translation table.
524  */
525  for (i = 0; i < maximum_colors; i++)
526  {
527  /* Only move the colors we need to */
528  if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
529  {
530  png_color tmp_color;
531 
532  do
533  j--;
534  while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
535 
536  tmp_color = palette[j];
537  palette[j] = palette[i];
538  palette[i] = tmp_color;
539  /* Indicate where the color went */
540  png_ptr->quantize_index[j] = (png_byte)i;
541  png_ptr->quantize_index[i] = (png_byte)j;
542  }
543  }
544 
545  /* Find closest color for those colors we are not using */
546  for (i = 0; i < num_palette; i++)
547  {
548  if ((int)png_ptr->quantize_index[i] >= maximum_colors)
549  {
550  int min_d, k, min_k, d_index;
551 
552  /* Find the closest color to one we threw out */
553  d_index = png_ptr->quantize_index[i];
554  min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
555  for (k = 1, min_k = 0; k < maximum_colors; k++)
556  {
557  int d;
558 
559  d = PNG_COLOR_DIST(palette[d_index], palette[k]);
560 
561  if (d < min_d)
562  {
563  min_d = d;
564  min_k = k;
565  }
566  }
567  /* Point to closest color */
568  png_ptr->quantize_index[i] = (png_byte)min_k;
569  }
570  }
571  }
572  png_free(png_ptr, png_ptr->quantize_sort);
573  png_ptr->quantize_sort = NULL;
574  }
575  else
576  {
577  /* This is much harder to do simply (and quickly). Perhaps
578  * we need to go through a median cut routine, but those
579  * don't always behave themselves with only a few colors
580  * as input. So we will just find the closest two colors,
581  * and throw out one of them (chosen somewhat randomly).
582  * [We don't understand this at all, so if someone wants to
583  * work on improving it, be our guest - AED, GRP]
584  */
585  int i;
586  int max_d;
587  int num_new_palette;
588  png_dsortp t;
589  png_dsortpp hash;
590 
591  t = NULL;
592 
593  /* Initialize palette index arrays */
594  png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
595  (png_alloc_size_t)((png_uint_32)num_palette *
596  (sizeof (png_byte))));
597  png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
598  (png_alloc_size_t)((png_uint_32)num_palette *
599  (sizeof (png_byte))));
600 
601  /* Initialize the sort array */
602  for (i = 0; i < num_palette; i++)
603  {
604  png_ptr->index_to_palette[i] = (png_byte)i;
605  png_ptr->palette_to_index[i] = (png_byte)i;
606  }
607 
608  hash = (png_dsortpp)png_calloc(png_ptr, (png_alloc_size_t)(769 *
609  (sizeof (png_dsortp))));
610 
611  num_new_palette = num_palette;
612 
613  /* Initial wild guess at how far apart the farthest pixel
614  * pair we will be eliminating will be. Larger
615  * numbers mean more areas will be allocated, Smaller
616  * numbers run the risk of not saving enough data, and
617  * having to do this all over again.
618  *
619  * I have not done extensive checking on this number.
620  */
621  max_d = 96;
622 
623  while (num_new_palette > maximum_colors)
624  {
625  for (i = 0; i < num_new_palette - 1; i++)
626  {
627  int j;
628 
629  for (j = i + 1; j < num_new_palette; j++)
630  {
631  int d;
632 
633  d = PNG_COLOR_DIST(palette[i], palette[j]);
634 
635  if (d <= max_d)
636  {
637 
638  t = (png_dsortp)png_malloc_warn(png_ptr,
639  (png_alloc_size_t)(sizeof (png_dsort)));
640 
641  if (t == NULL)
642  break;
643 
644  t->next = hash[d];
645  t->left = (png_byte)i;
646  t->right = (png_byte)j;
647  hash[d] = t;
648  }
649  }
650  if (t == NULL)
651  break;
652  }
653 
654  if (t != NULL)
655  for (i = 0; i <= max_d; i++)
656  {
657  if (hash[i] != NULL)
658  {
659  png_dsortp p;
660 
661  for (p = hash[i]; p; p = p->next)
662  {
663  if ((int)png_ptr->index_to_palette[p->left]
664  < num_new_palette &&
665  (int)png_ptr->index_to_palette[p->right]
666  < num_new_palette)
667  {
668  int j, next_j;
669 
670  if (num_new_palette & 0x01)
671  {
672  j = p->left;
673  next_j = p->right;
674  }
675  else
676  {
677  j = p->right;
678  next_j = p->left;
679  }
680 
681  num_new_palette--;
682  palette[png_ptr->index_to_palette[j]]
683  = palette[num_new_palette];
684  if (full_quantize == 0)
685  {
686  int k;
687 
688  for (k = 0; k < num_palette; k++)
689  {
690  if (png_ptr->quantize_index[k] ==
691  png_ptr->index_to_palette[j])
692  png_ptr->quantize_index[k] =
693  png_ptr->index_to_palette[next_j];
694 
695  if ((int)png_ptr->quantize_index[k] ==
696  num_new_palette)
697  png_ptr->quantize_index[k] =
698  png_ptr->index_to_palette[j];
699  }
700  }
701 
702  png_ptr->index_to_palette[png_ptr->palette_to_index
703  [num_new_palette]] = png_ptr->index_to_palette[j];
704 
705  png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
706  = png_ptr->palette_to_index[num_new_palette];
707 
708  png_ptr->index_to_palette[j] =
709  (png_byte)num_new_palette;
710 
711  png_ptr->palette_to_index[num_new_palette] =
712  (png_byte)j;
713  }
714  if (num_new_palette <= maximum_colors)
715  break;
716  }
717  if (num_new_palette <= maximum_colors)
718  break;
719  }
720  }
721 
722  for (i = 0; i < 769; i++)
723  {
724  if (hash[i] != NULL)
725  {
726  png_dsortp p = hash[i];
727  while (p)
728  {
729  t = p->next;
730  png_free(png_ptr, p);
731  p = t;
732  }
733  }
734  hash[i] = 0;
735  }
736  max_d += 96;
737  }
738  png_free(png_ptr, hash);
739  png_free(png_ptr, png_ptr->palette_to_index);
740  png_free(png_ptr, png_ptr->index_to_palette);
741  png_ptr->palette_to_index = NULL;
742  png_ptr->index_to_palette = NULL;
743  }
744  num_palette = maximum_colors;
745  }
746  if (png_ptr->palette == NULL)
747  {
748  png_ptr->palette = palette;
749  }
750  png_ptr->num_palette = (png_uint_16)num_palette;
751 
752  if (full_quantize != 0)
753  {
754  int i;
755  png_bytep distance;
756  int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS +
757  PNG_QUANTIZE_BLUE_BITS;
758  int num_red = (1 << PNG_QUANTIZE_RED_BITS);
759  int num_green = (1 << PNG_QUANTIZE_GREEN_BITS);
760  int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS);
761  size_t num_entries = ((size_t)1 << total_bits);
762 
763  png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,
764  (png_alloc_size_t)(num_entries * (sizeof (png_byte))));
765 
766  distance = (png_bytep)png_malloc(png_ptr, (png_alloc_size_t)(num_entries *
767  (sizeof (png_byte))));
768 
769  memset(distance, 0xff, num_entries * (sizeof (png_byte)));
770 
771  for (i = 0; i < num_palette; i++)
772  {
773  int ir, ig, ib;
774  int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS));
775  int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS));
776  int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS));
777 
778  for (ir = 0; ir < num_red; ir++)
779  {
780  /* int dr = abs(ir - r); */
781  int dr = ((ir > r) ? ir - r : r - ir);
782  int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS +
783  PNG_QUANTIZE_GREEN_BITS));
784 
785  for (ig = 0; ig < num_green; ig++)
786  {
787  /* int dg = abs(ig - g); */
788  int dg = ((ig > g) ? ig - g : g - ig);
789  int dt = dr + dg;
790  int dm = ((dr > dg) ? dr : dg);
791  int index_g = index_r | (ig << PNG_QUANTIZE_BLUE_BITS);
792 
793  for (ib = 0; ib < num_blue; ib++)
794  {
795  int d_index = index_g | ib;
796  /* int db = abs(ib - b); */
797  int db = ((ib > b) ? ib - b : b - ib);
798  int dmax = ((dm > db) ? dm : db);
799  int d = dmax + dt + db;
800 
801  if (d < (int)distance[d_index])
802  {
803  distance[d_index] = (png_byte)d;
804  png_ptr->palette_lookup[d_index] = (png_byte)i;
805  }
806  }
807  }
808  }
809  }
810 
811  png_free(png_ptr, distance);
812  }
813 }
Here is the call graph for this function:

◆ png_set_gamma_fixed()

void PNGFAPI png_set_gamma_fixed ( png_structrp  png_ptr,
png_fixed_point  scrn_gamma,
png_fixed_point  file_gamma 
)
820 {
821  png_debug(1, "in png_set_gamma_fixed");
822 
823  if (png_rtran_ok(png_ptr, 0) == 0)
824  return;
825 
826  /* New in libpng-1.5.4 - reserve particular negative values as flags. */
827  scrn_gamma = translate_gamma_flags(png_ptr, scrn_gamma, 1/*screen*/);
828  file_gamma = translate_gamma_flags(png_ptr, file_gamma, 0/*file*/);
829 
830  /* Checking the gamma values for being >0 was added in 1.5.4 along with the
831  * premultiplied alpha support; this actually hides an undocumented feature
832  * of the previous implementation which allowed gamma processing to be
833  * disabled in background handling. There is no evidence (so far) that this
834  * was being used; however, png_set_background itself accepted and must still
835  * accept '0' for the gamma value it takes, because it isn't always used.
836  *
837  * Since this is an API change (albeit a very minor one that removes an
838  * undocumented API feature) the following checks were only enabled in
839  * libpng-1.6.0.
840  */
841  if (file_gamma <= 0)
842  png_error(png_ptr, "invalid file gamma in png_set_gamma");
843 
844  if (scrn_gamma <= 0)
845  png_error(png_ptr, "invalid screen gamma in png_set_gamma");
846 
847  /* Set the gamma values unconditionally - this overrides the value in the PNG
848  * file if a gAMA chunk was present. png_set_alpha_mode provides a
849  * different, easier, way to default the file gamma.
850  */
851  png_ptr->colorspace.gamma = file_gamma;
852  png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
853  png_ptr->screen_gamma = scrn_gamma;
854 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_gamma()

void PNGAPI png_set_gamma ( png_structrp  png_ptr,
double  scrn_gamma,
double  file_gamma 
)
859 {
860  png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma),
861  convert_gamma_value(png_ptr, file_gamma));
862 }
Here is the call graph for this function:

◆ png_set_expand()

void PNGAPI png_set_expand ( png_structrp  png_ptr)
873 {
874  png_debug(1, "in png_set_expand");
875 
876  if (png_rtran_ok(png_ptr, 0) == 0)
877  return;
878 
879  png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
880 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_palette_to_rgb()

void PNGAPI png_set_palette_to_rgb ( png_structrp  png_ptr)
903 {
904  png_debug(1, "in png_set_palette_to_rgb");
905 
906  if (png_rtran_ok(png_ptr, 0) == 0)
907  return;
908 
909  png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
910 }
Here is the call graph for this function:

◆ png_set_expand_gray_1_2_4_to_8()

void PNGAPI png_set_expand_gray_1_2_4_to_8 ( png_structrp  png_ptr)
915 {
916  png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
917 
918  if (png_rtran_ok(png_ptr, 0) == 0)
919  return;
920 
921  png_ptr->transformations |= PNG_EXPAND;
922 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_tRNS_to_alpha()

void PNGAPI png_set_tRNS_to_alpha ( png_structrp  png_ptr)
927 {
928  png_debug(1, "in png_set_tRNS_to_alpha");
929 
930  if (png_rtran_ok(png_ptr, 0) == 0)
931  return;
932 
933  png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
934 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_expand_16()

void PNGAPI png_set_expand_16 ( png_structrp  png_ptr)
943 {
944  png_debug(1, "in png_set_expand_16");
945 
946  if (png_rtran_ok(png_ptr, 0) == 0)
947  return;
948 
949  png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS);
950 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_gray_to_rgb()

void PNGAPI png_set_gray_to_rgb ( png_structrp  png_ptr)
956 {
957  png_debug(1, "in png_set_gray_to_rgb");
958 
959  if (png_rtran_ok(png_ptr, 0) == 0)
960  return;
961 
962  /* Because rgb must be 8 bits or more: */
963  png_set_expand_gray_1_2_4_to_8(png_ptr);
964  png_ptr->transformations |= PNG_GRAY_TO_RGB;
965 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_rgb_to_gray_fixed()

void PNGFAPI png_set_rgb_to_gray_fixed ( png_structrp  png_ptr,
int  error_action,
png_fixed_point  red,
png_fixed_point  green 
)
972 {
973  png_debug(1, "in png_set_rgb_to_gray");
974 
975  /* Need the IHDR here because of the check on color_type below. */
976  /* TODO: fix this */
977  if (png_rtran_ok(png_ptr, 1) == 0)
978  return;
979 
980  switch (error_action)
981  {
982  case PNG_ERROR_ACTION_NONE:
983  png_ptr->transformations |= PNG_RGB_TO_GRAY;
984  break;
985 
986  case PNG_ERROR_ACTION_WARN:
987  png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
988  break;
989 
990  case PNG_ERROR_ACTION_ERROR:
991  png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
992  break;
993 
994  default:
995  png_error(png_ptr, "invalid error action to rgb_to_gray");
996  }
997 
998  if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
999 #ifdef PNG_READ_EXPAND_SUPPORTED
1000  png_ptr->transformations |= PNG_EXPAND;
1001 #else
1002  {
1003  /* Make this an error in 1.6 because otherwise the application may assume
1004  * that it just worked and get a memory overwrite.
1005  */
1006  png_error(png_ptr,
1007  "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");
1008 
1009  /* png_ptr->transformations &= ~PNG_RGB_TO_GRAY; */
1010  }
1011 #endif
1012  {
1013  if (red >= 0 && green >= 0 && red + green <= PNG_FP_1)
1014  {
1015  png_uint_16 red_int, green_int;
1016 
1017  /* NOTE: this calculation does not round, but this behavior is retained
1018  * for consistency; the inaccuracy is very small. The code here always
1019  * overwrites the coefficients, regardless of whether they have been
1020  * defaulted or set already.
1021  */
1022  red_int = (png_uint_16)(((png_uint_32)red*32768)/100000);
1023  green_int = (png_uint_16)(((png_uint_32)green*32768)/100000);
1024 
1025  png_ptr->rgb_to_gray_red_coeff = red_int;
1026  png_ptr->rgb_to_gray_green_coeff = green_int;
1027  png_ptr->rgb_to_gray_coefficients_set = 1;
1028  }
1029 
1030  else
1031  {
1032  if (red >= 0 && green >= 0)
1033  png_app_warning(png_ptr,
1034  "ignoring out of range rgb_to_gray coefficients");
1035 
1036  /* Use the defaults, from the cHRM chunk if set, else the historical
1037  * values which are close to the sRGB/HDTV/ITU-Rec 709 values. See
1038  * png_do_rgb_to_gray for more discussion of the values. In this case
1039  * the coefficients are not marked as 'set' and are not overwritten if
1040  * something has already provided a default.
1041  */
1042  if (png_ptr->rgb_to_gray_red_coeff == 0 &&
1043  png_ptr->rgb_to_gray_green_coeff == 0)
1044  {
1045  png_ptr->rgb_to_gray_red_coeff = 6968;
1046  png_ptr->rgb_to_gray_green_coeff = 23434;
1047  /* png_ptr->rgb_to_gray_blue_coeff = 2366; */
1048  }
1049  }
1050  }
1051 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_set_rgb_to_gray()

void PNGAPI png_set_rgb_to_gray ( png_structrp  png_ptr,
int  error_action,
double  red,
double  green 
)
1061 {
1062  png_set_rgb_to_gray_fixed(png_ptr, error_action,
1063  png_fixed(png_ptr, red, "rgb to gray red coefficient"),
1064  png_fixed(png_ptr, green, "rgb to gray green coefficient"));
1065 }
Here is the call graph for this function:

◆ png_set_read_user_transform_fn()

void PNGAPI png_set_read_user_transform_fn ( png_structrp  png_ptr,
png_user_transform_ptr  read_user_transform_fn 
)
1075 {
1076  png_debug(1, "in png_set_read_user_transform_fn");
1077 
1078 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
1079  png_ptr->transformations |= PNG_USER_TRANSFORM;
1080  png_ptr->read_user_transform_fn = read_user_transform_fn;
1081 #endif
1082 }

◆ png_gamma_threshold()

static int png_gamma_threshold ( png_fixed_point  screen_gamma,
png_fixed_point  file_gamma 
)
static
1093 {
1094  /* PNG_GAMMA_THRESHOLD is the threshold for performing gamma
1095  * correction as a difference of the overall transform from 1.0
1096  *
1097  * We want to compare the threshold with s*f - 1, if we get
1098  * overflow here it is because of wacky gamma values so we
1099  * turn on processing anyway.
1100  */
1101  png_fixed_point gtest;
1102  return !png_muldiv(&gtest, screen_gamma, file_gamma, PNG_FP_1) ||
1103  png_gamma_significant(gtest);
1104 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_init_palette_transformations()

static void png_init_palette_transformations ( png_structrp  png_ptr)
static
1118 {
1119  /* Called to handle the (input) palette case. In png_do_read_transformations
1120  * the first step is to expand the palette if requested, so this code must
1121  * take care to only make changes that are invariant with respect to the
1122  * palette expansion, or only do them if there is no expansion.
1123  *
1124  * STRIP_ALPHA has already been handled in the caller (by setting num_trans
1125  * to 0.)
1126  */
1127  int input_has_alpha = 0;
1128  int input_has_transparency = 0;
1129 
1130  if (png_ptr->num_trans > 0)
1131  {
1132  int i;
1133 
1134  /* Ignore if all the entries are opaque (unlikely!) */
1135  for (i=0; i<png_ptr->num_trans; ++i)
1136  {
1137  if (png_ptr->trans_alpha[i] == 255)
1138  continue;
1139  else if (png_ptr->trans_alpha[i] == 0)
1140  input_has_transparency = 1;
1141  else
1142  {
1143  input_has_transparency = 1;
1144  input_has_alpha = 1;
1145  break;
1146  }
1147  }
1148  }
1149 
1150  /* If no alpha we can optimize. */
1151  if (input_has_alpha == 0)
1152  {
1153  /* Any alpha means background and associative alpha processing is
1154  * required, however if the alpha is 0 or 1 throughout OPTIMIZE_ALPHA
1155  * and ENCODE_ALPHA are irrelevant.
1156  */
1157  png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
1158  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
1159 
1160  if (input_has_transparency == 0)
1161  png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND);
1162  }
1163 
1164 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
1165  /* png_set_background handling - deals with the complexity of whether the
1166  * background color is in the file format or the screen format in the case
1167  * where an 'expand' will happen.
1168  */
1169 
1170  /* The following code cannot be entered in the alpha pre-multiplication case
1171  * because PNG_BACKGROUND_EXPAND is cancelled below.
1172  */
1173  if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0 &&
1174  (png_ptr->transformations & PNG_EXPAND) != 0)
1175  {
1176  {
1177  png_ptr->background.red =
1178  png_ptr->palette[png_ptr->background.index].red;
1179  png_ptr->background.green =
1180  png_ptr->palette[png_ptr->background.index].green;
1181  png_ptr->background.blue =
1182  png_ptr->palette[png_ptr->background.index].blue;
1183 
1184 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
1185  if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
1186  {
1187  if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
1188  {
1189  /* Invert the alpha channel (in tRNS) unless the pixels are
1190  * going to be expanded, in which case leave it for later
1191  */
1192  int i, istop = png_ptr->num_trans;
1193 
1194  for (i=0; i<istop; i++)
1195  png_ptr->trans_alpha[i] = (png_byte)(255 -
1196  png_ptr->trans_alpha[i]);
1197  }
1198  }
1199 #endif /* READ_INVERT_ALPHA */
1200  }
1201  } /* background expand and (therefore) no alpha association. */
1202 #endif /* READ_EXPAND && READ_BACKGROUND */
1203 }
Here is the caller graph for this function:

◆ png_init_rgb_transformations()

static void png_init_rgb_transformations ( png_structrp  png_ptr)
static
1207 {
1208  /* Added to libpng-1.5.4: check the color type to determine whether there
1209  * is any alpha or transparency in the image and simply cancel the
1210  * background and alpha mode stuff if there isn't.
1211  */
1212  int input_has_alpha = (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0;
1213  int input_has_transparency = png_ptr->num_trans > 0;
1214 
1215  /* If no alpha we can optimize. */
1216  if (input_has_alpha == 0)
1217  {
1218  /* Any alpha means background and associative alpha processing is
1219  * required, however if the alpha is 0 or 1 throughout OPTIMIZE_ALPHA
1220  * and ENCODE_ALPHA are irrelevant.
1221  */
1222 # ifdef PNG_READ_ALPHA_MODE_SUPPORTED
1223  png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
1224  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
1225 # endif
1226 
1227  if (input_has_transparency == 0)
1228  png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND);
1229  }
1230 
1231 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
1232  /* png_set_background handling - deals with the complexity of whether the
1233  * background color is in the file format or the screen format in the case
1234  * where an 'expand' will happen.
1235  */
1236 
1237  /* The following code cannot be entered in the alpha pre-multiplication case
1238  * because PNG_BACKGROUND_EXPAND is cancelled below.
1239  */
1240  if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0 &&
1241  (png_ptr->transformations & PNG_EXPAND) != 0 &&
1242  (png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
1243  /* i.e., GRAY or GRAY_ALPHA */
1244  {
1245  {
1246  /* Expand background and tRNS chunks */
1247  int gray = png_ptr->background.gray;
1248  int trans_gray = png_ptr->trans_color.gray;
1249 
1250  switch (png_ptr->bit_depth)
1251  {
1252  case 1:
1253  gray *= 0xff;
1254  trans_gray *= 0xff;
1255  break;
1256 
1257  case 2:
1258  gray *= 0x55;
1259  trans_gray *= 0x55;
1260  break;
1261 
1262  case 4:
1263  gray *= 0x11;
1264  trans_gray *= 0x11;
1265  break;
1266 
1267  default:
1268 
1269  case 8:
1270  /* FALLTHROUGH */ /* (Already 8 bits) */
1271 
1272  case 16:
1273  /* Already a full 16 bits */
1274  break;
1275  }
1276 
1277  png_ptr->background.red = png_ptr->background.green =
1278  png_ptr->background.blue = (png_uint_16)gray;
1279 
1280  if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
1281  {
1282  png_ptr->trans_color.red = png_ptr->trans_color.green =
1283  png_ptr->trans_color.blue = (png_uint_16)trans_gray;
1284  }
1285  }
1286  } /* background expand and (therefore) no alpha association. */
1287 #endif /* READ_EXPAND && READ_BACKGROUND */
1288 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_init_read_transformations()

void png_init_read_transformations ( png_structrp  png_ptr)
1292 {
1293  png_debug(1, "in png_init_read_transformations");
1294 
1295  /* This internal function is called from png_read_start_row in pngrutil.c
1296  * and it is called before the 'rowbytes' calculation is done, so the code
1297  * in here can change or update the transformations flags.
1298  *
1299  * First do updates that do not depend on the details of the PNG image data
1300  * being processed.
1301  */
1302 
1303 #ifdef PNG_READ_GAMMA_SUPPORTED
1304  /* Prior to 1.5.4 these tests were performed from png_set_gamma, 1.5.4 adds
1305  * png_set_alpha_mode and this is another source for a default file gamma so
1306  * the test needs to be performed later - here. In addition prior to 1.5.4
1307  * the tests were repeated for the PALETTE color type here - this is no
1308  * longer necessary (and doesn't seem to have been necessary before.)
1309  */
1310  {
1311  /* The following temporary indicates if overall gamma correction is
1312  * required.
1313  */
1314  int gamma_correction = 0;
1315 
1316  if (png_ptr->colorspace.gamma != 0) /* has been set */
1317  {
1318  if (png_ptr->screen_gamma != 0) /* screen set too */
1319  gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma,
1320  png_ptr->screen_gamma);
1321 
1322  else
1323  /* Assume the output matches the input; a long time default behavior
1324  * of libpng, although the standard has nothing to say about this.
1325  */
1326  png_ptr->screen_gamma = png_reciprocal(png_ptr->colorspace.gamma);
1327  }
1328 
1329  else if (png_ptr->screen_gamma != 0)
1330  /* The converse - assume the file matches the screen, note that this
1331  * perhaps undesirable default can (from 1.5.4) be changed by calling
1332  * png_set_alpha_mode (even if the alpha handling mode isn't required
1333  * or isn't changed from the default.)
1334  */
1335  png_ptr->colorspace.gamma = png_reciprocal(png_ptr->screen_gamma);
1336 
1337  else /* neither are set */
1338  /* Just in case the following prevents any processing - file and screen
1339  * are both assumed to be linear and there is no way to introduce a
1340  * third gamma value other than png_set_background with 'UNIQUE', and,
1341  * prior to 1.5.4
1342  */
1343  png_ptr->screen_gamma = png_ptr->colorspace.gamma = PNG_FP_1;
1344 
1345  /* We have a gamma value now. */
1346  png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
1347 
1348  /* Now turn the gamma transformation on or off as appropriate. Notice
1349  * that PNG_GAMMA just refers to the file->screen correction. Alpha
1350  * composition may independently cause gamma correction because it needs
1351  * linear data (e.g. if the file has a gAMA chunk but the screen gamma
1352  * hasn't been specified.) In any case this flag may get turned off in
1353  * the code immediately below if the transform can be handled outside the
1354  * row loop.
1355  */
1356  if (gamma_correction != 0)
1357  png_ptr->transformations |= PNG_GAMMA;
1358 
1359  else
1360  png_ptr->transformations &= ~PNG_GAMMA;
1361  }
1362 #endif
1363 
1364  /* Certain transformations have the effect of preventing other
1365  * transformations that happen afterward in png_do_read_transformations;
1366  * resolve the interdependencies here. From the code of
1367  * png_do_read_transformations the order is:
1368  *
1369  * 1) PNG_EXPAND (including PNG_EXPAND_tRNS)
1370  * 2) PNG_STRIP_ALPHA (if no compose)
1371  * 3) PNG_RGB_TO_GRAY
1372  * 4) PNG_GRAY_TO_RGB iff !PNG_BACKGROUND_IS_GRAY
1373  * 5) PNG_COMPOSE
1374  * 6) PNG_GAMMA
1375  * 7) PNG_STRIP_ALPHA (if compose)
1376  * 8) PNG_ENCODE_ALPHA
1377  * 9) PNG_SCALE_16_TO_8
1378  * 10) PNG_16_TO_8
1379  * 11) PNG_QUANTIZE (converts to palette)
1380  * 12) PNG_EXPAND_16
1381  * 13) PNG_GRAY_TO_RGB iff PNG_BACKGROUND_IS_GRAY
1382  * 14) PNG_INVERT_MONO
1383  * 15) PNG_INVERT_ALPHA
1384  * 16) PNG_SHIFT
1385  * 17) PNG_PACK
1386  * 18) PNG_BGR
1387  * 19) PNG_PACKSWAP
1388  * 20) PNG_FILLER (includes PNG_ADD_ALPHA)
1389  * 21) PNG_SWAP_ALPHA
1390  * 22) PNG_SWAP_BYTES
1391  * 23) PNG_USER_TRANSFORM [must be last]
1392  */
1393 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
1394  if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
1395  (png_ptr->transformations & PNG_COMPOSE) == 0)
1396  {
1397  /* Stripping the alpha channel happens immediately after the 'expand'
1398  * transformations, before all other transformation, so it cancels out
1399  * the alpha handling. It has the side effect negating the effect of
1400  * PNG_EXPAND_tRNS too:
1401  */
1402  png_ptr->transformations &= ~(PNG_BACKGROUND_EXPAND | PNG_ENCODE_ALPHA |
1403  PNG_EXPAND_tRNS);
1404  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
1405 
1406  /* Kill the tRNS chunk itself too. Prior to 1.5.4 this did not happen
1407  * so transparency information would remain just so long as it wasn't
1408  * expanded. This produces unexpected API changes if the set of things
1409  * that do PNG_EXPAND_tRNS changes (perfectly possible given the
1410  * documentation - which says ask for what you want, accept what you
1411  * get.) This makes the behavior consistent from 1.5.4:
1412  */
1413  png_ptr->num_trans = 0;
1414  }
1415 #endif /* STRIP_ALPHA supported, no COMPOSE */
1416 
1417 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
1418  /* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA
1419  * settings will have no effect.
1420  */
1421  if (png_gamma_significant(png_ptr->screen_gamma) == 0)
1422  {
1423  png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
1424  png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
1425  }
1426 #endif
1427 
1428 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1429  /* Make sure the coefficients for the rgb to gray conversion are set
1430  * appropriately.
1431  */
1432  if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
1433  png_colorspace_set_rgb_coefficients(png_ptr);
1434 #endif
1435 
1436 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
1437 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
1438  /* Detect gray background and attempt to enable optimization for
1439  * gray --> RGB case.
1440  *
1441  * Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
1442  * RGB_ALPHA (in which case need_expand is superfluous anyway), the
1443  * background color might actually be gray yet not be flagged as such.
1444  * This is not a problem for the current code, which uses
1445  * PNG_BACKGROUND_IS_GRAY only to decide when to do the
1446  * png_do_gray_to_rgb() transformation.
1447  *
1448  * TODO: this code needs to be revised to avoid the complexity and
1449  * interdependencies. The color type of the background should be recorded in
1450  * png_set_background, along with the bit depth, then the code has a record
1451  * of exactly what color space the background is currently in.
1452  */
1453  if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0)
1454  {
1455  /* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if
1456  * the file was grayscale the background value is gray.
1457  */
1458  if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
1459  png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
1460  }
1461 
1462  else if ((png_ptr->transformations & PNG_COMPOSE) != 0)
1463  {
1464  /* PNG_COMPOSE: png_set_background was called with need_expand false,
1465  * so the color is in the color space of the output or png_set_alpha_mode
1466  * was called and the color is black. Ignore RGB_TO_GRAY because that
1467  * happens before GRAY_TO_RGB.
1468  */
1469  if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
1470  {
1471  if (png_ptr->background.red == png_ptr->background.green &&
1472  png_ptr->background.red == png_ptr->background.blue)
1473  {
1474  png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
1475  png_ptr->background.gray = png_ptr->background.red;
1476  }
1477  }
1478  }
1479 #endif /* READ_EXPAND && READ_BACKGROUND */
1480 #endif /* READ_GRAY_TO_RGB */
1481 
1482  /* For indexed PNG data (PNG_COLOR_TYPE_PALETTE) many of the transformations
1483  * can be performed directly on the palette, and some (such as rgb to gray)
1484  * can be optimized inside the palette. This is particularly true of the
1485  * composite (background and alpha) stuff, which can be pretty much all done
1486  * in the palette even if the result is expanded to RGB or gray afterward.
1487  *
1488  * NOTE: this is Not Yet Implemented, the code behaves as in 1.5.1 and
1489  * earlier and the palette stuff is actually handled on the first row. This
1490  * leads to the reported bug that the palette returned by png_get_PLTE is not
1491  * updated.
1492  */
1493  if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1494  png_init_palette_transformations(png_ptr);
1495 
1496  else
1497  png_init_rgb_transformations(png_ptr);
1498 
1499 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
1500  defined(PNG_READ_EXPAND_16_SUPPORTED)
1501  if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
1502  (png_ptr->transformations & PNG_COMPOSE) != 0 &&
1503  (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
1504  png_ptr->bit_depth != 16)
1505  {
1506  /* TODO: fix this. Because the expand_16 operation is after the compose
1507  * handling the background color must be 8, not 16, bits deep, but the
1508  * application will supply a 16-bit value so reduce it here.
1509  *
1510  * The PNG_BACKGROUND_EXPAND code above does not expand to 16 bits at
1511  * present, so that case is ok (until do_expand_16 is moved.)
1512  *
1513  * NOTE: this discards the low 16 bits of the user supplied background
1514  * color, but until expand_16 works properly there is no choice!
1515  */
1516 # define CHOP(x) (x)=((png_uint_16)PNG_DIV257(x))
1517  CHOP(png_ptr->background.red);
1518  CHOP(png_ptr->background.green);
1519  CHOP(png_ptr->background.blue);
1520  CHOP(png_ptr->background.gray);
1521 # undef CHOP
1522  }
1523 #endif /* READ_BACKGROUND && READ_EXPAND_16 */
1524 
1525 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
1526  (defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \
1527  defined(PNG_READ_STRIP_16_TO_8_SUPPORTED))
1528  if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) != 0 &&
1529  (png_ptr->transformations & PNG_COMPOSE) != 0 &&
1530  (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
1531  png_ptr->bit_depth == 16)
1532  {
1533  /* On the other hand, if a 16-bit file is to be reduced to 8-bits per
1534  * component this will also happen after PNG_COMPOSE and so the background
1535  * color must be pre-expanded here.
1536  *
1537  * TODO: fix this too.
1538  */
1539  png_ptr->background.red = (png_uint_16)(png_ptr->background.red * 257);
1540  png_ptr->background.green =
1541  (png_uint_16)(png_ptr->background.green * 257);
1542  png_ptr->background.blue = (png_uint_16)(png_ptr->background.blue * 257);
1543  png_ptr->background.gray = (png_uint_16)(png_ptr->background.gray * 257);
1544  }
1545 #endif
1546 
1547  /* NOTE: below 'PNG_READ_ALPHA_MODE_SUPPORTED' is presumed to also enable the
1548  * background support (see the comments in scripts/pnglibconf.dfa), this
1549  * allows pre-multiplication of the alpha channel to be implemented as
1550  * compositing on black. This is probably sub-optimal and has been done in
1551  * 1.5.4 betas simply to enable external critique and testing (i.e. to
1552  * implement the new API quickly, without lots of internal changes.)
1553  */
1554 
1555 #ifdef PNG_READ_GAMMA_SUPPORTED
1556 # ifdef PNG_READ_BACKGROUND_SUPPORTED
1557  /* Includes ALPHA_MODE */
1558  png_ptr->background_1 = png_ptr->background;
1559 # endif
1560 
1561  /* This needs to change - in the palette image case a whole set of tables are
1562  * built when it would be quicker to just calculate the correct value for
1563  * each palette entry directly. Also, the test is too tricky - why check
1564  * PNG_RGB_TO_GRAY if PNG_GAMMA is not set? The answer seems to be that
1565  * PNG_GAMMA is cancelled even if the gamma is known? The test excludes the
1566  * PNG_COMPOSE case, so apparently if there is no *overall* gamma correction
1567  * the gamma tables will not be built even if composition is required on a
1568  * gamma encoded value.
1569  *
1570  * In 1.5.4 this is addressed below by an additional check on the individual
1571  * file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the
1572  * tables.
1573  */
1574  if ((png_ptr->transformations & PNG_GAMMA) != 0 ||
1575  ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0 &&
1576  (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
1577  png_gamma_significant(png_ptr->screen_gamma) != 0)) ||
1578  ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
1579  (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
1580  png_gamma_significant(png_ptr->screen_gamma) != 0
1581 # ifdef PNG_READ_BACKGROUND_SUPPORTED
1582  || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE &&
1583  png_gamma_significant(png_ptr->background_gamma) != 0)
1584 # endif
1585  )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
1586  png_gamma_significant(png_ptr->screen_gamma) != 0))
1587  {
1588  png_build_gamma_table(png_ptr, png_ptr->bit_depth);
1589 
1590 #ifdef PNG_READ_BACKGROUND_SUPPORTED
1591  if ((png_ptr->transformations & PNG_COMPOSE) != 0)
1592  {
1593  /* Issue a warning about this combination: because RGB_TO_GRAY is
1594  * optimized to do the gamma transform if present yet do_background has
1595  * to do the same thing if both options are set a
1596  * double-gamma-correction happens. This is true in all versions of
1597  * libpng to date.
1598  */
1599  if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
1600  png_warning(png_ptr,
1601  "libpng does not support gamma+background+rgb_to_gray");
1602 
1603  if ((png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) != 0)
1604  {
1605  /* We don't get to here unless there is a tRNS chunk with non-opaque
1606  * entries - see the checking code at the start of this function.
1607  */
1608  png_color back, back_1;
1609  png_colorp palette = png_ptr->palette;
1610  int num_palette = png_ptr->num_palette;
1611  int i;
1612  if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
1613  {
1614 
1615  back.red = png_ptr->gamma_table[png_ptr->background.red];
1616  back.green = png_ptr->gamma_table[png_ptr->background.green];
1617  back.blue = png_ptr->gamma_table[png_ptr->background.blue];
1618 
1619  back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
1620  back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
1621  back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
1622  }
1623  else
1624  {
1625  png_fixed_point g, gs;
1626 
1627  switch (png_ptr->background_gamma_type)
1628  {
1629  case PNG_BACKGROUND_GAMMA_SCREEN:
1630  g = (png_ptr->screen_gamma);
1631  gs = PNG_FP_1;
1632  break;
1633 
1634  case PNG_BACKGROUND_GAMMA_FILE:
1635  g = png_reciprocal(png_ptr->colorspace.gamma);
1636  gs = png_reciprocal2(png_ptr->colorspace.gamma,
1637  png_ptr->screen_gamma);
1638  break;
1639 
1640  case PNG_BACKGROUND_GAMMA_UNIQUE:
1641  g = png_reciprocal(png_ptr->background_gamma);
1642  gs = png_reciprocal2(png_ptr->background_gamma,
1643  png_ptr->screen_gamma);
1644  break;
1645  default:
1646  g = PNG_FP_1; /* back_1 */
1647  gs = PNG_FP_1; /* back */
1648  break;
1649  }
1650 
1651  if (png_gamma_significant(gs) != 0)
1652  {
1653  back.red = png_gamma_8bit_correct(png_ptr->background.red,
1654  gs);
1655  back.green = png_gamma_8bit_correct(png_ptr->background.green,
1656  gs);
1657  back.blue = png_gamma_8bit_correct(png_ptr->background.blue,
1658  gs);
1659  }
1660 
1661  else
1662  {
1663  back.red = (png_byte)png_ptr->background.red;
1664  back.green = (png_byte)png_ptr->background.green;
1665  back.blue = (png_byte)png_ptr->background.blue;
1666  }
1667 
1668  if (png_gamma_significant(g) != 0)
1669  {
1670  back_1.red = png_gamma_8bit_correct(png_ptr->background.red,
1671  g);
1672  back_1.green = png_gamma_8bit_correct(
1673  png_ptr->background.green, g);
1674  back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue,
1675  g);
1676  }
1677 
1678  else
1679  {
1680  back_1.red = (png_byte)png_ptr->background.red;
1681  back_1.green = (png_byte)png_ptr->background.green;
1682  back_1.blue = (png_byte)png_ptr->background.blue;
1683  }
1684  }
1685 
1686  for (i = 0; i < num_palette; i++)
1687  {
1688  if (i < (int)png_ptr->num_trans &&
1689  png_ptr->trans_alpha[i] != 0xff)
1690  {
1691  if (png_ptr->trans_alpha[i] == 0)
1692  {
1693  palette[i] = back;
1694  }
1695  else /* if (png_ptr->trans_alpha[i] != 0xff) */
1696  {
1697  png_byte v, w;
1698 
1699  v = png_ptr->gamma_to_1[palette[i].red];
1700  png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);
1701  palette[i].red = png_ptr->gamma_from_1[w];
1702 
1703  v = png_ptr->gamma_to_1[palette[i].green];
1704  png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);
1705  palette[i].green = png_ptr->gamma_from_1[w];
1706 
1707  v = png_ptr->gamma_to_1[palette[i].blue];
1708  png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);
1709  palette[i].blue = png_ptr->gamma_from_1[w];
1710  }
1711  }
1712  else
1713  {
1714  palette[i].red = png_ptr->gamma_table[palette[i].red];
1715  palette[i].green = png_ptr->gamma_table[palette[i].green];
1716  palette[i].blue = png_ptr->gamma_table[palette[i].blue];
1717  }
1718  }
1719 
1720  /* Prevent the transformations being done again.
1721  *
1722  * NOTE: this is highly dubious; it removes the transformations in
1723  * place. This seems inconsistent with the general treatment of the
1724  * transformations elsewhere.
1725  */
1726  png_ptr->transformations &= ~(PNG_COMPOSE | PNG_GAMMA);
1727  } /* color_type == PNG_COLOR_TYPE_PALETTE */
1728 
1729  /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
1730  else /* color_type != PNG_COLOR_TYPE_PALETTE */
1731  {
1732  int gs_sig, g_sig;
1733  png_fixed_point g = PNG_FP_1; /* Correction to linear */
1734  png_fixed_point gs = PNG_FP_1; /* Correction to screen */
1735 
1736  switch (png_ptr->background_gamma_type)
1737  {
1738  case PNG_BACKGROUND_GAMMA_SCREEN:
1739  g = png_ptr->screen_gamma;
1740  /* gs = PNG_FP_1; */
1741  break;
1742 
1743  case PNG_BACKGROUND_GAMMA_FILE:
1744  g = png_reciprocal(png_ptr->colorspace.gamma);
1745  gs = png_reciprocal2(png_ptr->colorspace.gamma,
1746  png_ptr->screen_gamma);
1747  break;
1748 
1749  case PNG_BACKGROUND_GAMMA_UNIQUE:
1750  g = png_reciprocal(png_ptr->background_gamma);
1751  gs = png_reciprocal2(png_ptr->background_gamma,
1752  png_ptr->screen_gamma);
1753  break;
1754 
1755  default:
1756  png_error(png_ptr, "invalid background gamma type");
1757  }
1758 
1759  g_sig = png_gamma_significant(g);
1760  gs_sig = png_gamma_significant(gs);
1761 
1762  if (g_sig != 0)
1763  png_ptr->background_1.gray = png_gamma_correct(png_ptr,
1764  png_ptr->background.gray, g);
1765 
1766  if (gs_sig != 0)
1767  png_ptr->background.gray = png_gamma_correct(png_ptr,
1768  png_ptr->background.gray, gs);
1769 
1770  if ((png_ptr->background.red != png_ptr->background.green) ||
1771  (png_ptr->background.red != png_ptr->background.blue) ||
1772  (png_ptr->background.red != png_ptr->background.gray))
1773  {
1774  /* RGB or RGBA with color background */
1775  if (g_sig != 0)
1776  {
1777  png_ptr->background_1.red = png_gamma_correct(png_ptr,
1778  png_ptr->background.red, g);
1779 
1780  png_ptr->background_1.green = png_gamma_correct(png_ptr,
1781  png_ptr->background.green, g);
1782 
1783  png_ptr->background_1.blue = png_gamma_correct(png_ptr,
1784  png_ptr->background.blue, g);
1785  }
1786 
1787  if (gs_sig != 0)
1788  {
1789  png_ptr->background.red = png_gamma_correct(png_ptr,
1790  png_ptr->background.red, gs);
1791 
1792  png_ptr->background.green = png_gamma_correct(png_ptr,
1793  png_ptr->background.green, gs);
1794 
1795  png_ptr->background.blue = png_gamma_correct(png_ptr,
1796  png_ptr->background.blue, gs);
1797  }
1798  }
1799 
1800  else
1801  {
1802  /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
1803  png_ptr->background_1.red = png_ptr->background_1.green
1804  = png_ptr->background_1.blue = png_ptr->background_1.gray;
1805 
1806  png_ptr->background.red = png_ptr->background.green
1807  = png_ptr->background.blue = png_ptr->background.gray;
1808  }
1809 
1810  /* The background is now in screen gamma: */
1811  png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_SCREEN;
1812  } /* color_type != PNG_COLOR_TYPE_PALETTE */
1813  }/* png_ptr->transformations & PNG_BACKGROUND */
1814 
1815  else
1816  /* Transformation does not include PNG_BACKGROUND */
1817 #endif /* READ_BACKGROUND */
1818  if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE
1819 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1820  /* RGB_TO_GRAY needs to have non-gamma-corrected values! */
1821  && ((png_ptr->transformations & PNG_EXPAND) == 0 ||
1822  (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
1823 #endif
1824  )
1825  {
1826  png_colorp palette = png_ptr->palette;
1827  int num_palette = png_ptr->num_palette;
1828  int i;
1829 
1830  /* NOTE: there are other transformations that should probably be in
1831  * here too.
1832  */
1833  for (i = 0; i < num_palette; i++)
1834  {
1835  palette[i].red = png_ptr->gamma_table[palette[i].red];
1836  palette[i].green = png_ptr->gamma_table[palette[i].green];
1837  palette[i].blue = png_ptr->gamma_table[palette[i].blue];
1838  }
1839 
1840  /* Done the gamma correction. */
1841  png_ptr->transformations &= ~PNG_GAMMA;
1842  } /* color_type == PALETTE && !PNG_BACKGROUND transformation */
1843  }
1844 #ifdef PNG_READ_BACKGROUND_SUPPORTED
1845  else
1846 #endif
1847 #endif /* READ_GAMMA */
1848 
1849 #ifdef PNG_READ_BACKGROUND_SUPPORTED
1850  /* No GAMMA transformation (see the hanging else 4 lines above) */
1851  if ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
1852  (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
1853  {
1854  int i;
1855  int istop = (int)png_ptr->num_trans;
1856  png_color back;
1857  png_colorp palette = png_ptr->palette;
1858 
1859  back.red = (png_byte)png_ptr->background.red;
1860  back.green = (png_byte)png_ptr->background.green;
1861  back.blue = (png_byte)png_ptr->background.blue;
1862 
1863  for (i = 0; i < istop; i++)
1864  {
1865  if (png_ptr->trans_alpha[i] == 0)
1866  {
1867  palette[i] = back;
1868  }
1869 
1870  else if (png_ptr->trans_alpha[i] != 0xff)
1871  {
1872  /* The png_composite() macro is defined in png.h */
1873  png_composite(palette[i].red, palette[i].red,
1874  png_ptr->trans_alpha[i], back.red);
1875 
1876  png_composite(palette[i].green, palette[i].green,
1877  png_ptr->trans_alpha[i], back.green);
1878 
1879  png_composite(palette[i].blue, palette[i].blue,
1880  png_ptr->trans_alpha[i], back.blue);
1881  }
1882  }
1883 
1884  png_ptr->transformations &= ~PNG_COMPOSE;
1885  }
1886 #endif /* READ_BACKGROUND */
1887 
1888 #ifdef PNG_READ_SHIFT_SUPPORTED
1889  if ((png_ptr->transformations & PNG_SHIFT) != 0 &&
1890  (png_ptr->transformations & PNG_EXPAND) == 0 &&
1891  (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
1892  {
1893  int i;
1894  int istop = png_ptr->num_palette;
1895  int shift = 8 - png_ptr->sig_bit.red;
1896 
1897  png_ptr->transformations &= ~PNG_SHIFT;
1898 
1899  /* significant bits can be in the range 1 to 7 for a meaningful result, if
1900  * the number of significant bits is 0 then no shift is done (this is an
1901  * error condition which is silently ignored.)
1902  */
1903  if (shift > 0 && shift < 8)
1904  for (i=0; i<istop; ++i)
1905  {
1906  int component = png_ptr->palette[i].red;
1907 
1908  component >>= shift;
1909  png_ptr->palette[i].red = (png_byte)component;
1910  }
1911 
1912  shift = 8 - png_ptr->sig_bit.green;
1913  if (shift > 0 && shift < 8)
1914  for (i=0; i<istop; ++i)
1915  {
1916  int component = png_ptr->palette[i].green;
1917 
1918  component >>= shift;
1919  png_ptr->palette[i].green = (png_byte)component;
1920  }
1921 
1922  shift = 8 - png_ptr->sig_bit.blue;
1923  if (shift > 0 && shift < 8)
1924  for (i=0; i<istop; ++i)
1925  {
1926  int component = png_ptr->palette[i].blue;
1927 
1928  component >>= shift;
1929  png_ptr->palette[i].blue = (png_byte)component;
1930  }
1931  }
1932 #endif /* READ_SHIFT */
1933 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_read_transform_info()

void png_read_transform_info ( png_structrp  png_ptr,
png_inforp  info_ptr 
)
1941 {
1942  png_debug(1, "in png_read_transform_info");
1943 
1944 #ifdef PNG_READ_EXPAND_SUPPORTED
1945  if ((png_ptr->transformations & PNG_EXPAND) != 0)
1946  {
1947  if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
1948  {
1949  /* This check must match what actually happens in
1950  * png_do_expand_palette; if it ever checks the tRNS chunk to see if
1951  * it is all opaque we must do the same (at present it does not.)
1952  */
1953  if (png_ptr->num_trans > 0)
1954  info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
1955 
1956  else
1957  info_ptr->color_type = PNG_COLOR_TYPE_RGB;
1958 
1959  info_ptr->bit_depth = 8;
1960  info_ptr->num_trans = 0;
1961 
1962  if (png_ptr->palette == NULL)
1963  png_error (png_ptr, "Palette is NULL in indexed image");
1964  }
1965  else
1966  {
1967  if (png_ptr->num_trans != 0)
1968  {
1969  if ((png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
1970  info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
1971  }
1972  if (info_ptr->bit_depth < 8)
1973  info_ptr->bit_depth = 8;
1974 
1975  info_ptr->num_trans = 0;
1976  }
1977  }
1978 #endif
1979 
1980 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
1981  defined(PNG_READ_ALPHA_MODE_SUPPORTED)
1982  /* The following is almost certainly wrong unless the background value is in
1983  * the screen space!
1984  */
1985  if ((png_ptr->transformations & PNG_COMPOSE) != 0)
1986  info_ptr->background = png_ptr->background;
1987 #endif
1988 
1989 #ifdef PNG_READ_GAMMA_SUPPORTED
1990  /* The following used to be conditional on PNG_GAMMA (prior to 1.5.4),
1991  * however it seems that the code in png_init_read_transformations, which has
1992  * been called before this from png_read_update_info->png_read_start_row
1993  * sometimes does the gamma transform and cancels the flag.
1994  *
1995  * TODO: this looks wrong; the info_ptr should end up with a gamma equal to
1996  * the screen_gamma value. The following probably results in weirdness if
1997  * the info_ptr is used by the app after the rows have been read.
1998  */
1999  info_ptr->colorspace.gamma = png_ptr->colorspace.gamma;
2000 #endif
2001 
2002  if (info_ptr->bit_depth == 16)
2003  {
2004 # ifdef PNG_READ_16BIT_SUPPORTED
2005 # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
2006  if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
2007  info_ptr->bit_depth = 8;
2008 # endif
2009 
2010 # ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
2011  if ((png_ptr->transformations & PNG_16_TO_8) != 0)
2012  info_ptr->bit_depth = 8;
2013 # endif
2014 
2015 # else
2016  /* No 16-bit support: force chopping 16-bit input down to 8, in this case
2017  * the app program can chose if both APIs are available by setting the
2018  * correct scaling to use.
2019  */
2020 # ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
2021  /* For compatibility with previous versions use the strip method by
2022  * default. This code works because if PNG_SCALE_16_TO_8 is already
2023  * set the code below will do that in preference to the chop.
2024  */
2025  png_ptr->transformations |= PNG_16_TO_8;
2026  info_ptr->bit_depth = 8;
2027 # else
2028 
2029 # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
2030  png_ptr->transformations |= PNG_SCALE_16_TO_8;
2031  info_ptr->bit_depth = 8;
2032 # else
2033 
2034  CONFIGURATION ERROR: you must enable at least one 16 to 8 method
2035 # endif
2036 # endif
2037 #endif /* !READ_16BIT */
2038  }
2039 
2040 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
2041  if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
2042  info_ptr->color_type = (png_byte)(info_ptr->color_type |
2043  PNG_COLOR_MASK_COLOR);
2044 #endif
2045 
2046 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2047  if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
2048  info_ptr->color_type = (png_byte)(info_ptr->color_type &
2049  ~PNG_COLOR_MASK_COLOR);
2050 #endif
2051 
2052 #ifdef PNG_READ_QUANTIZE_SUPPORTED
2053  if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
2054  {
2055  if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
2056  (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
2057  png_ptr->palette_lookup != 0 && info_ptr->bit_depth == 8)
2058  {
2059  info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
2060  }
2061  }
2062 #endif
2063 
2064 #ifdef PNG_READ_EXPAND_16_SUPPORTED
2065  if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
2066  info_ptr->bit_depth == 8 &&
2067  info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
2068  {
2069  info_ptr->bit_depth = 16;
2070  }
2071 #endif
2072 
2073 #ifdef PNG_READ_PACK_SUPPORTED
2074  if ((png_ptr->transformations & PNG_PACK) != 0 &&
2075  (info_ptr->bit_depth < 8))
2076  info_ptr->bit_depth = 8;
2077 #endif
2078 
2079  if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
2080  info_ptr->channels = 1;
2081 
2082  else if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
2083  info_ptr->channels = 3;
2084 
2085  else
2086  info_ptr->channels = 1;
2087 
2088 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
2089  if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0)
2090  {
2091  info_ptr->color_type = (png_byte)(info_ptr->color_type &
2092  ~PNG_COLOR_MASK_ALPHA);
2093  info_ptr->num_trans = 0;
2094  }
2095 #endif
2096 
2097  if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
2098  info_ptr->channels++;
2099 
2100 #ifdef PNG_READ_FILLER_SUPPORTED
2101  /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */
2102  if ((png_ptr->transformations & PNG_FILLER) != 0 &&
2103  (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
2104  info_ptr->color_type == PNG_COLOR_TYPE_GRAY))
2105  {
2106  info_ptr->channels++;
2107  /* If adding a true alpha channel not just filler */
2108  if ((png_ptr->transformations & PNG_ADD_ALPHA) != 0)
2109  info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
2110  }
2111 #endif
2112 
2113 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
2114 defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
2115  if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
2116  {
2117  if (png_ptr->user_transform_depth != 0)
2118  info_ptr->bit_depth = png_ptr->user_transform_depth;
2119 
2120  if (png_ptr->user_transform_channels != 0)
2121  info_ptr->channels = png_ptr->user_transform_channels;
2122  }
2123 #endif
2124 
2125  info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
2126  info_ptr->bit_depth);
2127 
2128  info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
2129 
2130  /* Adding in 1.5.4: cache the above value in png_struct so that we can later
2131  * check in png_rowbytes that the user buffer won't get overwritten. Note
2132  * that the field is not always set - if png_read_update_info isn't called
2133  * the application has to either not do any transforms or get the calculation
2134  * right itself.
2135  */
2136  png_ptr->info_rowbytes = info_ptr->rowbytes;
2137 
2138 #ifndef PNG_READ_EXPAND_SUPPORTED
2139  if (png_ptr != NULL)
2140  return;
2141 #endif
2142 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_do_unpack()

static void png_do_unpack ( png_row_infop  row_info,
png_bytep  row 
)
static
2153 {
2154  png_debug(1, "in png_do_unpack");
2155 
2156  if (row_info->bit_depth < 8)
2157  {
2158  png_uint_32 i;
2159  png_uint_32 row_width=row_info->width;
2160 
2161  switch (row_info->bit_depth)
2162  {
2163  case 1:
2164  {
2165  png_bytep sp = row + (size_t)((row_width - 1) >> 3);
2166  png_bytep dp = row + (size_t)row_width - 1;
2167  png_uint_32 shift = 7U - ((row_width + 7U) & 0x07);
2168  for (i = 0; i < row_width; i++)
2169  {
2170  *dp = (png_byte)((*sp >> shift) & 0x01);
2171 
2172  if (shift == 7)
2173  {
2174  shift = 0;
2175  sp--;
2176  }
2177 
2178  else
2179  shift++;
2180 
2181  dp--;
2182  }
2183  break;
2184  }
2185 
2186  case 2:
2187  {
2188 
2189  png_bytep sp = row + (size_t)((row_width - 1) >> 2);
2190  png_bytep dp = row + (size_t)row_width - 1;
2191  png_uint_32 shift = ((3U - ((row_width + 3U) & 0x03)) << 1);
2192  for (i = 0; i < row_width; i++)
2193  {
2194  *dp = (png_byte)((*sp >> shift) & 0x03);
2195 
2196  if (shift == 6)
2197  {
2198  shift = 0;
2199  sp--;
2200  }
2201 
2202  else
2203  shift += 2;
2204 
2205  dp--;
2206  }
2207  break;
2208  }
2209 
2210  case 4:
2211  {
2212  png_bytep sp = row + (size_t)((row_width - 1) >> 1);
2213  png_bytep dp = row + (size_t)row_width - 1;
2214  png_uint_32 shift = ((1U - ((row_width + 1U) & 0x01)) << 2);
2215  for (i = 0; i < row_width; i++)
2216  {
2217  *dp = (png_byte)((*sp >> shift) & 0x0f);
2218 
2219  if (shift == 4)
2220  {
2221  shift = 0;
2222  sp--;
2223  }
2224 
2225  else
2226  shift = 4;
2227 
2228  dp--;
2229  }
2230  break;
2231  }
2232 
2233  default:
2234  break;
2235  }
2236  row_info->bit_depth = 8;
2237  row_info->pixel_depth = (png_byte)(8 * row_info->channels);
2238  row_info->rowbytes = row_width * row_info->channels;
2239  }
2240 }
Here is the caller graph for this function:

◆ png_do_unshift()

static void png_do_unshift ( png_row_infop  row_info,
png_bytep  row,
png_const_color_8p  sig_bits 
)
static
2252 {
2253  int color_type;
2254 
2255  png_debug(1, "in png_do_unshift");
2256 
2257  /* The palette case has already been handled in the _init routine. */
2258  color_type = row_info->color_type;
2259 
2260  if (color_type != PNG_COLOR_TYPE_PALETTE)
2261  {
2262  int shift[4];
2263  int channels = 0;
2264  int bit_depth = row_info->bit_depth;
2265 
2266  if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
2267  {
2268  shift[channels++] = bit_depth - sig_bits->red;
2269  shift[channels++] = bit_depth - sig_bits->green;
2270  shift[channels++] = bit_depth - sig_bits->blue;
2271  }
2272 
2273  else
2274  {
2275  shift[channels++] = bit_depth - sig_bits->gray;
2276  }
2277 
2278  if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
2279  {
2280  shift[channels++] = bit_depth - sig_bits->alpha;
2281  }
2282 
2283  {
2284  int c, have_shift;
2285 
2286  for (c = have_shift = 0; c < channels; ++c)
2287  {
2288  /* A shift of more than the bit depth is an error condition but it
2289  * gets ignored here.
2290  */
2291  if (shift[c] <= 0 || shift[c] >= bit_depth)
2292  shift[c] = 0;
2293 
2294  else
2295  have_shift = 1;
2296  }
2297 
2298  if (have_shift == 0)
2299  return;
2300  }
2301 
2302  switch (bit_depth)
2303  {
2304  default:
2305  /* Must be 1bpp gray: should not be here! */
2306  /* NOTREACHED */
2307  break;
2308 
2309  case 2:
2310  /* Must be 2bpp gray */
2311  /* assert(channels == 1 && shift[0] == 1) */
2312  {
2313  png_bytep bp = row;
2314  png_bytep bp_end = bp + row_info->rowbytes;
2315 
2316  while (bp < bp_end)
2317  {
2318  int b = (*bp >> 1) & 0x55;
2319  *bp++ = (png_byte)b;
2320  }
2321  break;
2322  }
2323 
2324  case 4:
2325  /* Must be 4bpp gray */
2326  /* assert(channels == 1) */
2327  {
2328  png_bytep bp = row;
2329  png_bytep bp_end = bp + row_info->rowbytes;
2330  int gray_shift = shift[0];
2331  int mask = 0xf >> gray_shift;
2332 
2333  mask |= mask << 4;
2334 
2335  while (bp < bp_end)
2336  {
2337  int b = (*bp >> gray_shift) & mask;
2338  *bp++ = (png_byte)b;
2339  }
2340  break;
2341  }
2342 
2343  case 8:
2344  /* Single byte components, G, GA, RGB, RGBA */
2345  {
2346  png_bytep bp = row;
2347  png_bytep bp_end = bp + row_info->rowbytes;
2348  int channel = 0;
2349 
2350  while (bp < bp_end)
2351  {
2352  int b = *bp >> shift[channel];
2353  if (++channel >= channels)
2354  channel = 0;
2355  *bp++ = (png_byte)b;
2356  }
2357  break;
2358  }
2359 
2360 #ifdef PNG_READ_16BIT_SUPPORTED
2361  case 16:
2362  /* Double byte components, G, GA, RGB, RGBA */
2363  {
2364  png_bytep bp = row;
2365  png_bytep bp_end = bp + row_info->rowbytes;
2366  int channel = 0;
2367 
2368  while (bp < bp_end)
2369  {
2370  int value = (bp[0] << 8) + bp[1];
2371 
2372  value >>= shift[channel];
2373  if (++channel >= channels)
2374  channel = 0;
2375  *bp++ = (png_byte)(value >> 8);
2376  *bp++ = (png_byte)value;
2377  }
2378  break;
2379  }
2380 #endif
2381  }
2382  }
2383 }
Here is the caller graph for this function:

◆ png_do_scale_16_to_8()

static void png_do_scale_16_to_8 ( png_row_infop  row_info,
png_bytep  row 
)
static
2390 {
2391  png_debug(1, "in png_do_scale_16_to_8");
2392 
2393  if (row_info->bit_depth == 16)
2394  {
2395  png_bytep sp = row; /* source */
2396  png_bytep dp = row; /* destination */
2397  png_bytep ep = sp + row_info->rowbytes; /* end+1 */
2398 
2399  while (sp < ep)
2400  {
2401  /* The input is an array of 16-bit components, these must be scaled to
2402  * 8 bits each. For a 16-bit value V the required value (from the PNG
2403  * specification) is:
2404  *
2405  * (V * 255) / 65535
2406  *
2407  * This reduces to round(V / 257), or floor((V + 128.5)/257)
2408  *
2409  * Represent V as the two byte value vhi.vlo. Make a guess that the
2410  * result is the top byte of V, vhi, then the correction to this value
2411  * is:
2412  *
2413  * error = floor(((V-vhi.vhi) + 128.5) / 257)
2414  * = floor(((vlo-vhi) + 128.5) / 257)
2415  *
2416  * This can be approximated using integer arithmetic (and a signed
2417  * shift):
2418  *
2419  * error = (vlo-vhi+128) >> 8;
2420  *
2421  * The approximate differs from the exact answer only when (vlo-vhi) is
2422  * 128; it then gives a correction of +1 when the exact correction is
2423  * 0. This gives 128 errors. The exact answer (correct for all 16-bit
2424  * input values) is:
2425  *
2426  * error = (vlo-vhi+128)*65535 >> 24;
2427  *
2428  * An alternative arithmetic calculation which also gives no errors is:
2429  *
2430  * (V * 255 + 32895) >> 16
2431  */
2432 
2433  png_int_32 tmp = *sp++; /* must be signed! */
2434  tmp += (((int)*sp++ - tmp + 128) * 65535) >> 24;
2435  *dp++ = (png_byte)tmp;
2436  }
2437 
2438  row_info->bit_depth = 8;
2439  row_info->pixel_depth = (png_byte)(8 * row_info->channels);
2440  row_info->rowbytes = row_info->width * row_info->channels;
2441  }
2442 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_do_chop()

static void png_do_chop ( png_row_infop  row_info,
png_bytep  row 
)
static
2451 {
2452  png_debug(1, "in png_do_chop");
2453 
2454  if (row_info->bit_depth == 16)
2455  {
2456  png_bytep sp = row; /* source */
2457  png_bytep dp = row; /* destination */
2458  png_bytep ep = sp + row_info->rowbytes; /* end+1 */
2459 
2460  while (sp < ep)
2461  {
2462  *dp++ = *sp;
2463  sp += 2; /* skip low byte */
2464  }
2465 
2466  row_info->bit_depth = 8;
2467  row_info->pixel_depth = (png_byte)(8 * row_info->channels);
2468  row_info->rowbytes = row_info->width * row_info->channels;
2469  }
2470 }
Here is the caller graph for this function:

◆ png_do_read_swap_alpha()

static void png_do_read_swap_alpha ( png_row_infop  row_info,
png_bytep  row 
)
static
2476 {
2477  png_uint_32 row_width = row_info->width;
2478 
2479  png_debug(1, "in png_do_read_swap_alpha");
2480 
2481  if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
2482  {
2483  /* This converts from RGBA to ARGB */
2484  if (row_info->bit_depth == 8)
2485  {
2486  png_bytep sp = row + row_info->rowbytes;
2487  png_bytep dp = sp;
2488  png_byte save;
2489  png_uint_32 i;
2490 
2491  for (i = 0; i < row_width; i++)
2492  {
2493  save = *(--sp);
2494  *(--dp) = *(--sp);
2495  *(--dp) = *(--sp);
2496  *(--dp) = *(--sp);
2497  *(--dp) = save;
2498  }
2499  }
2500 
2501 #ifdef PNG_READ_16BIT_SUPPORTED
2502  /* This converts from RRGGBBAA to AARRGGBB */
2503  else
2504  {
2505  png_bytep sp = row + row_info->rowbytes;
2506  png_bytep dp = sp;
2507  png_byte save[2];
2508  png_uint_32 i;
2509 
2510  for (i = 0; i < row_width; i++)
2511  {
2512  save[0] = *(--sp);
2513  save[1] = *(--sp);
2514  *(--dp) = *(--sp);
2515  *(--dp) = *(--sp);
2516  *(--dp) = *(--sp);
2517  *(--dp) = *(--sp);
2518  *(--dp) = *(--sp);
2519  *(--dp) = *(--sp);
2520  *(--dp) = save[0];
2521  *(--dp) = save[1];
2522  }
2523  }
2524 #endif
2525  }
2526 
2527  else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
2528  {
2529  /* This converts from GA to AG */
2530  if (row_info->bit_depth == 8)
2531  {
2532  png_bytep sp = row + row_info->rowbytes;
2533  png_bytep dp = sp;
2534  png_byte save;
2535  png_uint_32 i;
2536 
2537  for (i = 0; i < row_width; i++)
2538  {
2539  save = *(--sp);
2540  *(--dp) = *(--sp);
2541  *(--dp) = save;
2542  }
2543  }
2544 
2545 #ifdef PNG_READ_16BIT_SUPPORTED
2546  /* This converts from GGAA to AAGG */
2547  else
2548  {
2549  png_bytep sp = row + row_info->rowbytes;
2550  png_bytep dp = sp;
2551  png_byte save[2];
2552  png_uint_32 i;
2553 
2554  for (i = 0; i < row_width; i++)
2555  {
2556  save[0] = *(--sp);
2557  save[1] = *(--sp);
2558  *(--dp) = *(--sp);
2559  *(--dp) = *(--sp);
2560  *(--dp) = save[0];
2561  *(--dp) = save[1];
2562  }
2563  }
2564 #endif
2565  }
2566 }
Here is the caller graph for this function:

◆ png_do_read_invert_alpha()

static void png_do_read_invert_alpha ( png_row_infop  row_info,
png_bytep  row 
)
static
2572 {
2573  png_uint_32 row_width;
2574  png_debug(1, "in png_do_read_invert_alpha");
2575 
2576  row_width = row_info->width;
2577  if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
2578  {
2579  if (row_info->bit_depth == 8)
2580  {
2581  /* This inverts the alpha channel in RGBA */
2582  png_bytep sp = row + row_info->rowbytes;
2583  png_bytep dp = sp;
2584  png_uint_32 i;
2585 
2586  for (i = 0; i < row_width; i++)
2587  {
2588  *(--dp) = (png_byte)(255 - *(--sp));
2589 
2590 /* This does nothing:
2591  *(--dp) = *(--sp);
2592  *(--dp) = *(--sp);
2593  *(--dp) = *(--sp);
2594  We can replace it with:
2595 */
2596  sp-=3;
2597  dp=sp;
2598  }
2599  }
2600 
2601 #ifdef PNG_READ_16BIT_SUPPORTED
2602  /* This inverts the alpha channel in RRGGBBAA */
2603  else
2604  {
2605  png_bytep sp = row + row_info->rowbytes;
2606  png_bytep dp = sp;
2607  png_uint_32 i;
2608 
2609  for (i = 0; i < row_width; i++)
2610  {
2611  *(--dp) = (png_byte)(255 - *(--sp));
2612  *(--dp) = (png_byte)(255 - *(--sp));
2613 
2614 /* This does nothing:
2615  *(--dp) = *(--sp);
2616  *(--dp) = *(--sp);
2617  *(--dp) = *(--sp);
2618  *(--dp) = *(--sp);
2619  *(--dp) = *(--sp);
2620  *(--dp) = *(--sp);
2621  We can replace it with:
2622 */
2623  sp-=6;
2624  dp=sp;
2625  }
2626  }
2627 #endif
2628  }
2629  else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
2630  {
2631  if (row_info->bit_depth == 8)
2632  {
2633  /* This inverts the alpha channel in GA */
2634  png_bytep sp = row + row_info->rowbytes;
2635  png_bytep dp = sp;
2636  png_uint_32 i;
2637 
2638  for (i = 0; i < row_width; i++)
2639  {
2640  *(--dp) = (png_byte)(255 - *(--sp));
2641  *(--dp) = *(--sp);
2642  }
2643  }
2644 
2645 #ifdef PNG_READ_16BIT_SUPPORTED
2646  else
2647  {
2648  /* This inverts the alpha channel in GGAA */
2649  png_bytep sp = row + row_info->rowbytes;
2650  png_bytep dp = sp;
2651  png_uint_32 i;
2652 
2653  for (i = 0; i < row_width; i++)
2654  {
2655  *(--dp) = (png_byte)(255 - *(--sp));
2656  *(--dp) = (png_byte)(255 - *(--sp));
2657 /*
2658  *(--dp) = *(--sp);
2659  *(--dp) = *(--sp);
2660 */
2661  sp-=2;
2662  dp=sp;
2663  }
2664  }
2665 #endif
2666  }
2667 }
Here is the caller graph for this function:

◆ png_do_read_filler()

static void png_do_read_filler ( png_row_infop  row_info,
png_bytep  row,
png_uint_32  filler,
png_uint_32  flags 
)
static
2675 {
2676  png_uint_32 i;
2677  png_uint_32 row_width = row_info->width;
2678 
2679 #ifdef PNG_READ_16BIT_SUPPORTED
2680  png_byte hi_filler = (png_byte)(filler>>8);
2681 #endif
2682  png_byte lo_filler = (png_byte)filler;
2683 
2684  png_debug(1, "in png_do_read_filler");
2685 
2686  if (
2687  row_info->color_type == PNG_COLOR_TYPE_GRAY)
2688  {
2689  if (row_info->bit_depth == 8)
2690  {
2691  if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
2692  {
2693  /* This changes the data from G to GX */
2694  png_bytep sp = row + (size_t)row_width;
2695  png_bytep dp = sp + (size_t)row_width;
2696  for (i = 1; i < row_width; i++)
2697  {
2698  *(--dp) = lo_filler;
2699  *(--dp) = *(--sp);
2700  }
2701  *(--dp) = lo_filler;
2702  row_info->channels = 2;
2703  row_info->pixel_depth = 16;
2704  row_info->rowbytes = row_width * 2;
2705  }
2706 
2707  else
2708  {
2709  /* This changes the data from G to XG */
2710  png_bytep sp = row + (size_t)row_width;
2711  png_bytep dp = sp + (size_t)row_width;
2712  for (i = 0; i < row_width; i++)
2713  {
2714  *(--dp) = *(--sp);
2715  *(--dp) = lo_filler;
2716  }
2717  row_info->channels = 2;
2718  row_info->pixel_depth = 16;
2719  row_info->rowbytes = row_width * 2;
2720  }
2721  }
2722 
2723 #ifdef PNG_READ_16BIT_SUPPORTED
2724  else if (row_info->bit_depth == 16)
2725  {
2726  if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
2727  {
2728  /* This changes the data from GG to GGXX */
2729  png_bytep sp = row + (size_t)row_width * 2;
2730  png_bytep dp = sp + (size_t)row_width * 2;
2731  for (i = 1; i < row_width; i++)
2732  {
2733  *(--dp) = lo_filler;
2734  *(--dp) = hi_filler;
2735  *(--dp) = *(--sp);
2736  *(--dp) = *(--sp);
2737  }
2738  *(--dp) = lo_filler;
2739  *(--dp) = hi_filler;
2740  row_info->channels = 2;
2741  row_info->pixel_depth = 32;
2742  row_info->rowbytes = row_width * 4;
2743  }
2744 
2745  else
2746  {
2747  /* This changes the data from GG to XXGG */
2748  png_bytep sp = row + (size_t)row_width * 2;
2749  png_bytep dp = sp + (size_t)row_width * 2;
2750  for (i = 0; i < row_width; i++)
2751  {
2752  *(--dp) = *(--sp);
2753  *(--dp) = *(--sp);
2754  *(--dp) = lo_filler;
2755  *(--dp) = hi_filler;
2756  }
2757  row_info->channels = 2;
2758  row_info->pixel_depth = 32;
2759  row_info->rowbytes = row_width * 4;
2760  }
2761  }
2762 #endif
2763  } /* COLOR_TYPE == GRAY */
2764  else if (row_info->color_type == PNG_COLOR_TYPE_RGB)
2765  {
2766  if (row_info->bit_depth == 8)
2767  {
2768  if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
2769  {
2770  /* This changes the data from RGB to RGBX */
2771  png_bytep sp = row + (size_t)row_width * 3;
2772  png_bytep dp = sp + (size_t)row_width;
2773  for (i = 1; i < row_width; i++)
2774  {
2775  *(--dp) = lo_filler;
2776  *(--dp) = *(--sp);
2777  *(--dp) = *(--sp);
2778  *(--dp) = *(--sp);
2779  }
2780  *(--dp) = lo_filler;
2781  row_info->channels = 4;
2782  row_info->pixel_depth = 32;
2783  row_info->rowbytes = row_width * 4;
2784  }
2785 
2786  else
2787  {
2788  /* This changes the data from RGB to XRGB */
2789  png_bytep sp = row + (size_t)row_width * 3;
2790  png_bytep dp = sp + (size_t)row_width;
2791  for (i = 0; i < row_width; i++)
2792  {
2793  *(--dp) = *(--sp);
2794  *(--dp) = *(--sp);
2795  *(--dp) = *(--sp);
2796  *(--dp) = lo_filler;
2797  }
2798  row_info->channels = 4;
2799  row_info->pixel_depth = 32;
2800  row_info->rowbytes = row_width * 4;
2801  }
2802  }
2803 
2804 #ifdef PNG_READ_16BIT_SUPPORTED
2805  else if (row_info->bit_depth == 16)
2806  {
2807  if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
2808  {
2809  /* This changes the data from RRGGBB to RRGGBBXX */
2810  png_bytep sp = row + (size_t)row_width * 6;
2811  png_bytep dp = sp + (size_t)row_width * 2;
2812  for (i = 1; i < row_width; i++)
2813  {
2814  *(--dp) = lo_filler;
2815  *(--dp) = hi_filler;
2816  *(--dp) = *(--sp);
2817  *(--dp) = *(--sp);
2818  *(--dp) = *(--sp);
2819  *(--dp) = *(--sp);
2820  *(--dp) = *(--sp);
2821  *(--dp) = *(--sp);
2822  }
2823  *(--dp) = lo_filler;
2824  *(--dp) = hi_filler;
2825  row_info->channels = 4;
2826  row_info->pixel_depth = 64;
2827  row_info->rowbytes = row_width * 8;
2828  }
2829 
2830  else
2831  {
2832  /* This changes the data from RRGGBB to XXRRGGBB */
2833  png_bytep sp = row + (size_t)row_width * 6;
2834  png_bytep dp = sp + (size_t)row_width * 2;
2835  for (i = 0; i < row_width; i++)
2836  {
2837  *(--dp) = *(--sp);
2838  *(--dp) = *(--sp);
2839  *(--dp) = *(--sp);
2840  *(--dp) = *(--sp);
2841  *(--dp) = *(--sp);
2842  *(--dp) = *(--sp);
2843  *(--dp) = lo_filler;
2844  *(--dp) = hi_filler;
2845  }
2846 
2847  row_info->channels = 4;
2848  row_info->pixel_depth = 64;
2849  row_info->rowbytes = row_width * 8;
2850  }
2851  }
2852 #endif
2853  } /* COLOR_TYPE == RGB */
2854 }
Here is the caller graph for this function:

◆ png_do_gray_to_rgb()

static void png_do_gray_to_rgb ( png_row_infop  row_info,
png_bytep  row 
)
static
2861 {
2862  png_uint_32 i;
2863  png_uint_32 row_width = row_info->width;
2864 
2865  png_debug(1, "in png_do_gray_to_rgb");
2866 
2867  if (row_info->bit_depth >= 8 &&
2868  (row_info->color_type & PNG_COLOR_MASK_COLOR) == 0)
2869  {
2870  if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
2871  {
2872  if (row_info->bit_depth == 8)
2873  {
2874  /* This changes G to RGB */
2875  png_bytep sp = row + (size_t)row_width - 1;
2876  png_bytep dp = sp + (size_t)row_width * 2;
2877  for (i = 0; i < row_width; i++)
2878  {
2879  *(dp--) = *sp;
2880  *(dp--) = *sp;
2881  *(dp--) = *(sp--);
2882  }
2883  }
2884 
2885  else
2886  {
2887  /* This changes GG to RRGGBB */
2888  png_bytep sp = row + (size_t)row_width * 2 - 1;
2889  png_bytep dp = sp + (size_t)row_width * 4;
2890  for (i = 0; i < row_width; i++)
2891  {
2892  *(dp--) = *sp;
2893  *(dp--) = *(sp - 1);
2894  *(dp--) = *sp;
2895  *(dp--) = *(sp - 1);
2896  *(dp--) = *(sp--);
2897  *(dp--) = *(sp--);
2898  }
2899  }
2900  }
2901 
2902  else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
2903  {
2904  if (row_info->bit_depth == 8)
2905  {
2906  /* This changes GA to RGBA */
2907  png_bytep sp = row + (size_t)row_width * 2 - 1;
2908  png_bytep dp = sp + (size_t)row_width * 2;
2909  for (i = 0; i < row_width; i++)
2910  {
2911  *(dp--) = *(sp--);
2912  *(dp--) = *sp;
2913  *(dp--) = *sp;
2914  *(dp--) = *(sp--);
2915  }
2916  }
2917 
2918  else
2919  {
2920  /* This changes GGAA to RRGGBBAA */
2921  png_bytep sp = row + (size_t)row_width * 4 - 1;
2922  png_bytep dp = sp + (size_t)row_width * 4;
2923  for (i = 0; i < row_width; i++)
2924  {
2925  *(dp--) = *(sp--);
2926  *(dp--) = *(sp--);
2927  *(dp--) = *sp;
2928  *(dp--) = *(sp - 1);
2929  *(dp--) = *sp;
2930  *(dp--) = *(sp - 1);
2931  *(dp--) = *(sp--);
2932  *(dp--) = *(sp--);
2933  }
2934  }
2935  }
2936  row_info->channels = (png_byte)(row_info->channels + 2);
2937  row_info->color_type |= PNG_COLOR_MASK_COLOR;
2938  row_info->pixel_depth = (png_byte)(row_info->channels *
2939  row_info->bit_depth);
2940  row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
2941  }
2942 }
Here is the caller graph for this function:

◆ png_do_rgb_to_gray()

static int png_do_rgb_to_gray ( png_structrp  png_ptr,
png_row_infop  row_info,
png_bytep  row 
)
static
3000 {
3001  int rgb_error = 0;
3002 
3003  png_debug(1, "in png_do_rgb_to_gray");
3004 
3005  if ((row_info->color_type & PNG_COLOR_MASK_PALETTE) == 0 &&
3006  (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
3007  {
3008  png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
3009  png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
3010  png_uint_32 bc = 32768 - rc - gc;
3011  png_uint_32 row_width = row_info->width;
3012  int have_alpha = (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0;
3013 
3014  if (row_info->bit_depth == 8)
3015  {
3016 #ifdef PNG_READ_GAMMA_SUPPORTED
3017  /* Notice that gamma to/from 1 are not necessarily inverses (if
3018  * there is an overall gamma correction). Prior to 1.5.5 this code
3019  * checked the linearized values for equality; this doesn't match
3020  * the documentation, the original values must be checked.
3021  */
3022  if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
3023  {
3024  png_bytep sp = row;
3025  png_bytep dp = row;
3026  png_uint_32 i;
3027 
3028  for (i = 0; i < row_width; i++)
3029  {
3030  png_byte red = *(sp++);
3031  png_byte green = *(sp++);
3032  png_byte blue = *(sp++);
3033 
3034  if (red != green || red != blue)
3035  {
3036  red = png_ptr->gamma_to_1[red];
3037  green = png_ptr->gamma_to_1[green];
3038  blue = png_ptr->gamma_to_1[blue];
3039 
3040  rgb_error |= 1;
3041  *(dp++) = png_ptr->gamma_from_1[
3042  (rc*red + gc*green + bc*blue + 16384)>>15];
3043  }
3044 
3045  else
3046  {
3047  /* If there is no overall correction the table will not be
3048  * set.
3049  */
3050  if (png_ptr->gamma_table != NULL)
3051  red = png_ptr->gamma_table[red];
3052 
3053  *(dp++) = red;
3054  }
3055 
3056  if (have_alpha != 0)
3057  *(dp++) = *(sp++);
3058  }
3059  }
3060  else
3061 #endif
3062  {
3063  png_bytep sp = row;
3064  png_bytep dp = row;
3065  png_uint_32 i;
3066 
3067  for (i = 0; i < row_width; i++)
3068  {
3069  png_byte red = *(sp++);
3070  png_byte green = *(sp++);
3071  png_byte blue = *(sp++);
3072 
3073  if (red != green || red != blue)
3074  {
3075  rgb_error |= 1;
3076  /* NOTE: this is the historical approach which simply
3077  * truncates the results.
3078  */
3079  *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
3080  }
3081 
3082  else
3083  *(dp++) = red;
3084 
3085  if (have_alpha != 0)
3086  *(dp++) = *(sp++);
3087  }
3088  }
3089  }
3090 
3091  else /* RGB bit_depth == 16 */
3092  {
3093 #ifdef PNG_READ_GAMMA_SUPPORTED
3094  if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_1 != NULL)
3095  {
3096  png_bytep sp = row;
3097  png_bytep dp = row;
3098  png_uint_32 i;
3099 
3100  for (i = 0; i < row_width; i++)
3101  {
3102  png_uint_16 red, green, blue, w;
3103  png_byte hi,lo;
3104 
3105  hi=*(sp)++; lo=*(sp)++; red = (png_uint_16)((hi << 8) | (lo));
3106  hi=*(sp)++; lo=*(sp)++; green = (png_uint_16)((hi << 8) | (lo));
3107  hi=*(sp)++; lo=*(sp)++; blue = (png_uint_16)((hi << 8) | (lo));
3108 
3109  if (red == green && red == blue)
3110  {
3111  if (png_ptr->gamma_16_table != NULL)
3112  w = png_ptr->gamma_16_table[(red & 0xff)
3113  >> png_ptr->gamma_shift][red >> 8];
3114 
3115  else
3116  w = red;
3117  }
3118 
3119  else
3120  {
3121  png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red & 0xff)
3122  >> png_ptr->gamma_shift][red>>8];
3123  png_uint_16 green_1 =
3124  png_ptr->gamma_16_to_1[(green & 0xff) >>
3125  png_ptr->gamma_shift][green>>8];
3126  png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue & 0xff)
3127  >> png_ptr->gamma_shift][blue>>8];
3128  png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1
3129  + bc*blue_1 + 16384)>>15);
3130  w = png_ptr->gamma_16_from_1[(gray16 & 0xff) >>
3131  png_ptr->gamma_shift][gray16 >> 8];
3132  rgb_error |= 1;
3133  }
3134 
3135  *(dp++) = (png_byte)((w>>8) & 0xff);
3136  *(dp++) = (png_byte)(w & 0xff);
3137 
3138  if (have_alpha != 0)
3139  {
3140  *(dp++) = *(sp++);
3141  *(dp++) = *(sp++);
3142  }
3143  }
3144  }
3145  else
3146 #endif
3147  {
3148  png_bytep sp = row;
3149  png_bytep dp = row;
3150  png_uint_32 i;
3151 
3152  for (i = 0; i < row_width; i++)
3153  {
3154  png_uint_16 red, green, blue, gray16;
3155  png_byte hi,lo;
3156 
3157  hi=*(sp)++; lo=*(sp)++; red = (png_uint_16)((hi << 8) | (lo));
3158  hi=*(sp)++; lo=*(sp)++; green = (png_uint_16)((hi << 8) | (lo));
3159  hi=*(sp)++; lo=*(sp)++; blue = (png_uint_16)((hi << 8) | (lo));
3160 
3161  if (red != green || red != blue)
3162  rgb_error |= 1;
3163 
3164  /* From 1.5.5 in the 16-bit case do the accurate conversion even
3165  * in the 'fast' case - this is because this is where the code
3166  * ends up when handling linear 16-bit data.
3167  */
3168  gray16 = (png_uint_16)((rc*red + gc*green + bc*blue + 16384) >>
3169  15);
3170  *(dp++) = (png_byte)((gray16 >> 8) & 0xff);
3171  *(dp++) = (png_byte)(gray16 & 0xff);
3172 
3173  if (have_alpha != 0)
3174  {
3175  *(dp++) = *(sp++);
3176  *(dp++) = *(sp++);
3177  }
3178  }
3179  }
3180  }
3181 
3182  row_info->channels = (png_byte)(row_info->channels - 2);
3183  row_info->color_type = (png_byte)(row_info->color_type &
3184  ~PNG_COLOR_MASK_COLOR);
3185  row_info->pixel_depth = (png_byte)(row_info->channels *
3186  row_info->bit_depth);
3187  row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
3188  }
3189  return rgb_error;
3190 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_do_compose()

static void png_do_compose ( png_row_infop  row_info,
png_bytep  row,
png_structrp  png_ptr 
)
static
3201 {
3202 #ifdef PNG_READ_GAMMA_SUPPORTED
3203  png_const_bytep gamma_table = png_ptr->gamma_table;
3204  png_const_bytep gamma_from_1 = png_ptr->gamma_from_1;
3205  png_const_bytep gamma_to_1 = png_ptr->gamma_to_1;
3206  png_const_uint_16pp gamma_16 = png_ptr->gamma_16_table;
3207  png_const_uint_16pp gamma_16_from_1 = png_ptr->gamma_16_from_1;
3208  png_const_uint_16pp gamma_16_to_1 = png_ptr->gamma_16_to_1;
3209  int gamma_shift = png_ptr->gamma_shift;
3210  int optimize = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0;
3211 #endif
3212 
3213  png_bytep sp;
3214  png_uint_32 i;
3215  png_uint_32 row_width = row_info->width;
3216  int shift;
3217 
3218  png_debug(1, "in png_do_compose");
3219 
3220  switch (row_info->color_type)
3221  {
3222  case PNG_COLOR_TYPE_GRAY:
3223  {
3224  switch (row_info->bit_depth)
3225  {
3226  case 1:
3227  {
3228  sp = row;
3229  shift = 7;
3230  for (i = 0; i < row_width; i++)
3231  {
3232  if ((png_uint_16)((*sp >> shift) & 0x01)
3233  == png_ptr->trans_color.gray)
3234  {
3235  unsigned int tmp = *sp & (0x7f7f >> (7 - shift));
3236  tmp |=
3237  (unsigned int)(png_ptr->background.gray << shift);
3238  *sp = (png_byte)(tmp & 0xff);
3239  }
3240 
3241  if (shift == 0)
3242  {
3243  shift = 7;
3244  sp++;
3245  }
3246 
3247  else
3248  shift--;
3249  }
3250  break;
3251  }
3252 
3253  case 2:
3254  {
3255 #ifdef PNG_READ_GAMMA_SUPPORTED
3256  if (gamma_table != NULL)
3257  {
3258  sp = row;
3259  shift = 6;
3260  for (i = 0; i < row_width; i++)
3261  {
3262  if ((png_uint_16)((*sp >> shift) & 0x03)
3263  == png_ptr->trans_color.gray)
3264  {
3265  unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
3266  tmp |=
3267  (unsigned int)png_ptr->background.gray << shift;
3268  *sp = (png_byte)(tmp & 0xff);
3269  }
3270 
3271  else
3272  {
3273  unsigned int p = (*sp >> shift) & 0x03;
3274  unsigned int g = (gamma_table [p | (p << 2) |
3275  (p << 4) | (p << 6)] >> 6) & 0x03;
3276  unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
3277  tmp |= (unsigned int)(g << shift);
3278  *sp = (png_byte)(tmp & 0xff);
3279  }
3280 
3281  if (shift == 0)
3282  {
3283  shift = 6;
3284  sp++;
3285  }
3286 
3287  else
3288  shift -= 2;
3289  }
3290  }
3291 
3292  else
3293 #endif
3294  {
3295  sp = row;
3296  shift = 6;
3297  for (i = 0; i < row_width; i++)
3298  {
3299  if ((png_uint_16)((*sp >> shift) & 0x03)
3300  == png_ptr->trans_color.gray)
3301  {
3302  unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
3303  tmp |=
3304  (unsigned int)png_ptr->background.gray << shift;
3305  *sp = (png_byte)(tmp & 0xff);
3306  }
3307 
3308  if (shift == 0)
3309  {
3310  shift = 6;
3311  sp++;
3312  }
3313 
3314  else
3315  shift -= 2;
3316  }
3317  }
3318  break;
3319  }
3320 
3321  case 4:
3322  {
3323 #ifdef PNG_READ_GAMMA_SUPPORTED
3324  if (gamma_table != NULL)
3325  {
3326  sp = row;
3327  shift = 4;
3328  for (i = 0; i < row_width; i++)
3329  {
3330  if ((png_uint_16)((*sp >> shift) & 0x0f)
3331  == png_ptr->trans_color.gray)
3332  {
3333  unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
3334  tmp |=
3335  (unsigned int)(png_ptr->background.gray << shift);
3336  *sp = (png_byte)(tmp & 0xff);
3337  }
3338 
3339  else
3340  {
3341  unsigned int p = (*sp >> shift) & 0x0f;
3342  unsigned int g = (gamma_table[p | (p << 4)] >> 4) &
3343  0x0f;
3344  unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
3345  tmp |= (unsigned int)(g << shift);
3346  *sp = (png_byte)(tmp & 0xff);
3347  }
3348 
3349  if (shift == 0)
3350  {
3351  shift = 4;
3352  sp++;
3353  }
3354 
3355  else
3356  shift -= 4;
3357  }
3358  }
3359 
3360  else
3361 #endif
3362  {
3363  sp = row;
3364  shift = 4;
3365  for (i = 0; i < row_width; i++)
3366  {
3367  if ((png_uint_16)((*sp >> shift) & 0x0f)
3368  == png_ptr->trans_color.gray)
3369  {
3370  unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
3371  tmp |=
3372  (unsigned int)(png_ptr->background.gray << shift);
3373  *sp = (png_byte)(tmp & 0xff);
3374  }
3375 
3376  if (shift == 0)
3377  {
3378  shift = 4;
3379  sp++;
3380  }
3381 
3382  else
3383  shift -= 4;
3384  }
3385  }
3386  break;
3387  }
3388 
3389  case 8:
3390  {
3391 #ifdef PNG_READ_GAMMA_SUPPORTED
3392  if (gamma_table != NULL)
3393  {
3394  sp = row;
3395  for (i = 0; i < row_width; i++, sp++)
3396  {
3397  if (*sp == png_ptr->trans_color.gray)
3398  *sp = (png_byte)png_ptr->background.gray;
3399 
3400  else
3401  *sp = gamma_table[*sp];
3402  }
3403  }
3404  else
3405 #endif
3406  {
3407  sp = row;
3408  for (i = 0; i < row_width; i++, sp++)
3409  {
3410  if (*sp == png_ptr->trans_color.gray)
3411  *sp = (png_byte)png_ptr->background.gray;
3412  }
3413  }
3414  break;
3415  }
3416 
3417  case 16:
3418  {
3419 #ifdef PNG_READ_GAMMA_SUPPORTED
3420  if (gamma_16 != NULL)
3421  {
3422  sp = row;
3423  for (i = 0; i < row_width; i++, sp += 2)
3424  {
3425  png_uint_16 v;
3426 
3427  v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3428 
3429  if (v == png_ptr->trans_color.gray)
3430  {
3431  /* Background is already in screen gamma */
3432  *sp = (png_byte)((png_ptr->background.gray >> 8)
3433  & 0xff);
3434  *(sp + 1) = (png_byte)(png_ptr->background.gray
3435  & 0xff);
3436  }
3437 
3438  else
3439  {
3440  v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
3441  *sp = (png_byte)((v >> 8) & 0xff);
3442  *(sp + 1) = (png_byte)(v & 0xff);
3443  }
3444  }
3445  }
3446  else
3447 #endif
3448  {
3449  sp = row;
3450  for (i = 0; i < row_width; i++, sp += 2)
3451  {
3452  png_uint_16 v;
3453 
3454  v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3455 
3456  if (v == png_ptr->trans_color.gray)
3457  {
3458  *sp = (png_byte)((png_ptr->background.gray >> 8)
3459  & 0xff);
3460  *(sp + 1) = (png_byte)(png_ptr->background.gray
3461  & 0xff);
3462  }
3463  }
3464  }
3465  break;
3466  }
3467 
3468  default:
3469  break;
3470  }
3471  break;
3472  }
3473 
3474  case PNG_COLOR_TYPE_RGB:
3475  {
3476  if (row_info->bit_depth == 8)
3477  {
3478 #ifdef PNG_READ_GAMMA_SUPPORTED
3479  if (gamma_table != NULL)
3480  {
3481  sp = row;
3482  for (i = 0; i < row_width; i++, sp += 3)
3483  {
3484  if (*sp == png_ptr->trans_color.red &&
3485  *(sp + 1) == png_ptr->trans_color.green &&
3486  *(sp + 2) == png_ptr->trans_color.blue)
3487  {
3488  *sp = (png_byte)png_ptr->background.red;
3489  *(sp + 1) = (png_byte)png_ptr->background.green;
3490  *(sp + 2) = (png_byte)png_ptr->background.blue;
3491  }
3492 
3493  else
3494  {
3495  *sp = gamma_table[*sp];
3496  *(sp + 1) = gamma_table[*(sp + 1)];
3497  *(sp + 2) = gamma_table[*(sp + 2)];
3498  }
3499  }
3500  }
3501  else
3502 #endif
3503  {
3504  sp = row;
3505  for (i = 0; i < row_width; i++, sp += 3)
3506  {
3507  if (*sp == png_ptr->trans_color.red &&
3508  *(sp + 1) == png_ptr->trans_color.green &&
3509  *(sp + 2) == png_ptr->trans_color.blue)
3510  {
3511  *sp = (png_byte)png_ptr->background.red;
3512  *(sp + 1) = (png_byte)png_ptr->background.green;
3513  *(sp + 2) = (png_byte)png_ptr->background.blue;
3514  }
3515  }
3516  }
3517  }
3518  else /* if (row_info->bit_depth == 16) */
3519  {
3520 #ifdef PNG_READ_GAMMA_SUPPORTED
3521  if (gamma_16 != NULL)
3522  {
3523  sp = row;
3524  for (i = 0; i < row_width; i++, sp += 6)
3525  {
3526  png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3527 
3528  png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
3529  + *(sp + 3));
3530 
3531  png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
3532  + *(sp + 5));
3533 
3534  if (r == png_ptr->trans_color.red &&
3535  g == png_ptr->trans_color.green &&
3536  b == png_ptr->trans_color.blue)
3537  {
3538  /* Background is already in screen gamma */
3539  *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
3540  *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
3541  *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
3542  & 0xff);
3543  *(sp + 3) = (png_byte)(png_ptr->background.green
3544  & 0xff);
3545  *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
3546  & 0xff);
3547  *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
3548  }
3549 
3550  else
3551  {
3552  png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
3553  *sp = (png_byte)((v >> 8) & 0xff);
3554  *(sp + 1) = (png_byte)(v & 0xff);
3555 
3556  v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
3557  *(sp + 2) = (png_byte)((v >> 8) & 0xff);
3558  *(sp + 3) = (png_byte)(v & 0xff);
3559 
3560  v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
3561  *(sp + 4) = (png_byte)((v >> 8) & 0xff);
3562  *(sp + 5) = (png_byte)(v & 0xff);
3563  }
3564  }
3565  }
3566 
3567  else
3568 #endif
3569  {
3570  sp = row;
3571  for (i = 0; i < row_width; i++, sp += 6)
3572  {
3573  png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3574 
3575  png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
3576  + *(sp + 3));
3577 
3578  png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
3579  + *(sp + 5));
3580 
3581  if (r == png_ptr->trans_color.red &&
3582  g == png_ptr->trans_color.green &&
3583  b == png_ptr->trans_color.blue)
3584  {
3585  *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
3586  *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
3587  *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
3588  & 0xff);
3589  *(sp + 3) = (png_byte)(png_ptr->background.green
3590  & 0xff);
3591  *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
3592  & 0xff);
3593  *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
3594  }
3595  }
3596  }
3597  }
3598  break;
3599  }
3600 
3601  case PNG_COLOR_TYPE_GRAY_ALPHA:
3602  {
3603  if (row_info->bit_depth == 8)
3604  {
3605 #ifdef PNG_READ_GAMMA_SUPPORTED
3606  if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
3607  gamma_table != NULL)
3608  {
3609  sp = row;
3610  for (i = 0; i < row_width; i++, sp += 2)
3611  {
3612  png_uint_16 a = *(sp + 1);
3613 
3614  if (a == 0xff)
3615  *sp = gamma_table[*sp];
3616 
3617  else if (a == 0)
3618  {
3619  /* Background is already in screen gamma */
3620  *sp = (png_byte)png_ptr->background.gray;
3621  }
3622 
3623  else
3624  {
3625  png_byte v, w;
3626 
3627  v = gamma_to_1[*sp];
3628  png_composite(w, v, a, png_ptr->background_1.gray);
3629  if (optimize == 0)
3630  w = gamma_from_1[w];
3631  *sp = w;
3632  }
3633  }
3634  }
3635  else
3636 #endif
3637  {
3638  sp = row;
3639  for (i = 0; i < row_width; i++, sp += 2)
3640  {
3641  png_byte a = *(sp + 1);
3642 
3643  if (a == 0)
3644  *sp = (png_byte)png_ptr->background.gray;
3645 
3646  else if (a < 0xff)
3647  png_composite(*sp, *sp, a, png_ptr->background.gray);
3648  }
3649  }
3650  }
3651  else /* if (png_ptr->bit_depth == 16) */
3652  {
3653 #ifdef PNG_READ_GAMMA_SUPPORTED
3654  if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
3655  gamma_16_to_1 != NULL)
3656  {
3657  sp = row;
3658  for (i = 0; i < row_width; i++, sp += 4)
3659  {
3660  png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
3661  + *(sp + 3));
3662 
3663  if (a == (png_uint_16)0xffff)
3664  {
3665  png_uint_16 v;
3666 
3667  v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
3668  *sp = (png_byte)((v >> 8) & 0xff);
3669  *(sp + 1) = (png_byte)(v & 0xff);
3670  }
3671 
3672  else if (a == 0)
3673  {
3674  /* Background is already in screen gamma */
3675  *sp = (png_byte)((png_ptr->background.gray >> 8)
3676  & 0xff);
3677  *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
3678  }
3679 
3680  else
3681  {
3682  png_uint_16 g, v, w;
3683 
3684  g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
3685  png_composite_16(v, g, a, png_ptr->background_1.gray);
3686  if (optimize != 0)
3687  w = v;
3688  else
3689  w = gamma_16_from_1[(v & 0xff) >>
3690  gamma_shift][v >> 8];
3691  *sp = (png_byte)((w >> 8) & 0xff);
3692  *(sp + 1) = (png_byte)(w & 0xff);
3693  }
3694  }
3695  }
3696  else
3697 #endif
3698  {
3699  sp = row;
3700  for (i = 0; i < row_width; i++, sp += 4)
3701  {
3702  png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
3703  + *(sp + 3));
3704 
3705  if (a == 0)
3706  {
3707  *sp = (png_byte)((png_ptr->background.gray >> 8)
3708  & 0xff);
3709  *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
3710  }
3711 
3712  else if (a < 0xffff)
3713  {
3714  png_uint_16 g, v;
3715 
3716  g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3717  png_composite_16(v, g, a, png_ptr->background.gray);
3718  *sp = (png_byte)((v >> 8) & 0xff);
3719  *(sp + 1) = (png_byte)(v & 0xff);
3720  }
3721  }
3722  }
3723  }
3724  break;
3725  }
3726 
3727  case PNG_COLOR_TYPE_RGB_ALPHA:
3728  {
3729  if (row_info->bit_depth == 8)
3730  {
3731 #ifdef PNG_READ_GAMMA_SUPPORTED
3732  if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
3733  gamma_table != NULL)
3734  {
3735  sp = row;
3736  for (i = 0; i < row_width; i++, sp += 4)
3737  {
3738  png_byte a = *(sp + 3);
3739 
3740  if (a == 0xff)
3741  {
3742  *sp = gamma_table[*sp];
3743  *(sp + 1) = gamma_table[*(sp + 1)];
3744  *(sp + 2) = gamma_table[*(sp + 2)];
3745  }
3746 
3747  else if (a == 0)
3748  {
3749  /* Background is already in screen gamma */
3750  *sp = (png_byte)png_ptr->background.red;
3751  *(sp + 1) = (png_byte)png_ptr->background.green;
3752  *(sp + 2) = (png_byte)png_ptr->background.blue;
3753  }
3754 
3755  else
3756  {
3757  png_byte v, w;
3758 
3759  v = gamma_to_1[*sp];
3760  png_composite(w, v, a, png_ptr->background_1.red);
3761  if (optimize == 0) w = gamma_from_1[w];
3762  *sp = w;
3763 
3764  v = gamma_to_1[*(sp + 1)];
3765  png_composite(w, v, a, png_ptr->background_1.green);
3766  if (optimize == 0) w = gamma_from_1[w];
3767  *(sp + 1) = w;
3768 
3769  v = gamma_to_1[*(sp + 2)];
3770  png_composite(w, v, a, png_ptr->background_1.blue);
3771  if (optimize == 0) w = gamma_from_1[w];
3772  *(sp + 2) = w;
3773  }
3774  }
3775  }
3776  else
3777 #endif
3778  {
3779  sp = row;
3780  for (i = 0; i < row_width; i++, sp += 4)
3781  {
3782  png_byte a = *(sp + 3);
3783 
3784  if (a == 0)
3785  {
3786  *sp = (png_byte)png_ptr->background.red;
3787  *(sp + 1) = (png_byte)png_ptr->background.green;
3788  *(sp + 2) = (png_byte)png_ptr->background.blue;
3789  }
3790 
3791  else if (a < 0xff)
3792  {
3793  png_composite(*sp, *sp, a, png_ptr->background.red);
3794 
3795  png_composite(*(sp + 1), *(sp + 1), a,
3796  png_ptr->background.green);
3797 
3798  png_composite(*(sp + 2), *(sp + 2), a,
3799  png_ptr->background.blue);
3800  }
3801  }
3802  }
3803  }
3804  else /* if (row_info->bit_depth == 16) */
3805  {
3806 #ifdef PNG_READ_GAMMA_SUPPORTED
3807  if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
3808  gamma_16_to_1 != NULL)
3809  {
3810  sp = row;
3811  for (i = 0; i < row_width; i++, sp += 8)
3812  {
3813  png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
3814  << 8) + (png_uint_16)(*(sp + 7)));
3815 
3816  if (a == (png_uint_16)0xffff)
3817  {
3818  png_uint_16 v;
3819 
3820  v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
3821  *sp = (png_byte)((v >> 8) & 0xff);
3822  *(sp + 1) = (png_byte)(v & 0xff);
3823 
3824  v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
3825  *(sp + 2) = (png_byte)((v >> 8) & 0xff);
3826  *(sp + 3) = (png_byte)(v & 0xff);
3827 
3828  v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
3829  *(sp + 4) = (png_byte)((v >> 8) & 0xff);
3830  *(sp + 5) = (png_byte)(v & 0xff);
3831  }
3832 
3833  else if (a == 0)
3834  {
3835  /* Background is already in screen gamma */
3836  *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
3837  *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
3838  *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
3839  & 0xff);
3840  *(sp + 3) = (png_byte)(png_ptr->background.green
3841  & 0xff);
3842  *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
3843  & 0xff);
3844  *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
3845  }
3846 
3847  else
3848  {
3849  png_uint_16 v, w;
3850 
3851  v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
3852  png_composite_16(w, v, a, png_ptr->background_1.red);
3853  if (optimize == 0)
3854  w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
3855  8];
3856  *sp = (png_byte)((w >> 8) & 0xff);
3857  *(sp + 1) = (png_byte)(w & 0xff);
3858 
3859  v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
3860  png_composite_16(w, v, a, png_ptr->background_1.green);
3861  if (optimize == 0)
3862  w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
3863  8];
3864 
3865  *(sp + 2) = (png_byte)((w >> 8) & 0xff);
3866  *(sp + 3) = (png_byte)(w & 0xff);
3867 
3868  v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
3869  png_composite_16(w, v, a, png_ptr->background_1.blue);
3870  if (optimize == 0)
3871  w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
3872  8];
3873 
3874  *(sp + 4) = (png_byte)((w >> 8) & 0xff);
3875  *(sp + 5) = (png_byte)(w & 0xff);
3876  }
3877  }
3878  }
3879 
3880  else
3881 #endif
3882  {
3883  sp = row;
3884  for (i = 0; i < row_width; i++, sp += 8)
3885  {
3886  png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
3887  << 8) + (png_uint_16)(*(sp + 7)));
3888 
3889  if (a == 0)
3890  {
3891  *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
3892  *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
3893  *(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
3894  & 0xff);
3895  *(sp + 3) = (png_byte)(png_ptr->background.green
3896  & 0xff);
3897  *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
3898  & 0xff);
3899  *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
3900  }
3901 
3902  else if (a < 0xffff)
3903  {
3904  png_uint_16 v;
3905 
3906  png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
3907  png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
3908  + *(sp + 3));
3909  png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
3910  + *(sp + 5));
3911 
3912  png_composite_16(v, r, a, png_ptr->background.red);
3913  *sp = (png_byte)((v >> 8) & 0xff);
3914  *(sp + 1) = (png_byte)(v & 0xff);
3915 
3916  png_composite_16(v, g, a, png_ptr->background.green);
3917  *(sp + 2) = (png_byte)((v >> 8) & 0xff);
3918  *(sp + 3) = (png_byte)(v & 0xff);
3919 
3920  png_composite_16(v, b, a, png_ptr->background.blue);
3921  *(sp + 4) = (png_byte)((v >> 8) & 0xff);
3922  *(sp + 5) = (png_byte)(v & 0xff);
3923  }
3924  }
3925  }
3926  }
3927  break;
3928  }
3929 
3930  default:
3931  break;
3932  }
3933 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_do_gamma()

static void png_do_gamma ( png_row_infop  row_info,
png_bytep  row,
png_structrp  png_ptr 
)
static
3945 {
3946  png_const_bytep gamma_table = png_ptr->gamma_table;
3947  png_const_uint_16pp gamma_16_table = png_ptr->gamma_16_table;
3948  int gamma_shift = png_ptr->gamma_shift;
3949 
3950  png_bytep sp;
3951  png_uint_32 i;
3952  png_uint_32 row_width=row_info->width;
3953 
3954  png_debug(1, "in png_do_gamma");
3955 
3956  if (((row_info->bit_depth <= 8 && gamma_table != NULL) ||
3957  (row_info->bit_depth == 16 && gamma_16_table != NULL)))
3958  {
3959  switch (row_info->color_type)
3960  {
3961  case PNG_COLOR_TYPE_RGB:
3962  {
3963  if (row_info->bit_depth == 8)
3964  {
3965  sp = row;
3966  for (i = 0; i < row_width; i++)
3967  {
3968  *sp = gamma_table[*sp];
3969  sp++;
3970  *sp = gamma_table[*sp];
3971  sp++;
3972  *sp = gamma_table[*sp];
3973  sp++;
3974  }
3975  }
3976 
3977  else /* if (row_info->bit_depth == 16) */
3978  {
3979  sp = row;
3980  for (i = 0; i < row_width; i++)
3981  {
3982  png_uint_16 v;
3983 
3984  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3985  *sp = (png_byte)((v >> 8) & 0xff);
3986  *(sp + 1) = (png_byte)(v & 0xff);
3987  sp += 2;
3988 
3989  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3990  *sp = (png_byte)((v >> 8) & 0xff);
3991  *(sp + 1) = (png_byte)(v & 0xff);
3992  sp += 2;
3993 
3994  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
3995  *sp = (png_byte)((v >> 8) & 0xff);
3996  *(sp + 1) = (png_byte)(v & 0xff);
3997  sp += 2;
3998  }
3999  }
4000  break;
4001  }
4002 
4003  case PNG_COLOR_TYPE_RGB_ALPHA:
4004  {
4005  if (row_info->bit_depth == 8)
4006  {
4007  sp = row;
4008  for (i = 0; i < row_width; i++)
4009  {
4010  *sp = gamma_table[*sp];
4011  sp++;
4012 
4013  *sp = gamma_table[*sp];
4014  sp++;
4015 
4016  *sp = gamma_table[*sp];
4017  sp++;
4018 
4019  sp++;
4020  }
4021  }
4022 
4023  else /* if (row_info->bit_depth == 16) */
4024  {
4025  sp = row;
4026  for (i = 0; i < row_width; i++)
4027  {
4028  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
4029  *sp = (png_byte)((v >> 8) & 0xff);
4030  *(sp + 1) = (png_byte)(v & 0xff);
4031  sp += 2;
4032 
4033  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
4034  *sp = (png_byte)((v >> 8) & 0xff);
4035  *(sp + 1) = (png_byte)(v & 0xff);
4036  sp += 2;
4037 
4038  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
4039  *sp = (png_byte)((v >> 8) & 0xff);
4040  *(sp + 1) = (png_byte)(v & 0xff);
4041  sp += 4;
4042  }
4043  }
4044  break;
4045  }
4046 
4047  case PNG_COLOR_TYPE_GRAY_ALPHA:
4048  {
4049  if (row_info->bit_depth == 8)
4050  {
4051  sp = row;
4052  for (i = 0; i < row_width; i++)
4053  {
4054  *sp = gamma_table[*sp];
4055  sp += 2;
4056  }
4057  }
4058 
4059  else /* if (row_info->bit_depth == 16) */
4060  {
4061  sp = row;
4062  for (i = 0; i < row_width; i++)
4063  {
4064  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
4065  *sp = (png_byte)((v >> 8) & 0xff);
4066  *(sp + 1) = (png_byte)(v & 0xff);
4067  sp += 4;
4068  }
4069  }
4070  break;
4071  }
4072 
4073  case PNG_COLOR_TYPE_GRAY:
4074  {
4075  if (row_info->bit_depth == 2)
4076  {
4077  sp = row;
4078  for (i = 0; i < row_width; i += 4)
4079  {
4080  int a = *sp & 0xc0;
4081  int b = *sp & 0x30;
4082  int c = *sp & 0x0c;
4083  int d = *sp & 0x03;
4084 
4085  *sp = (png_byte)(
4086  ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)|
4087  ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|
4088  ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|
4089  ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));
4090  sp++;
4091  }
4092  }
4093 
4094  if (row_info->bit_depth == 4)
4095  {
4096  sp = row;
4097  for (i = 0; i < row_width; i += 2)
4098  {
4099  int msb = *sp & 0xf0;
4100  int lsb = *sp & 0x0f;
4101 
4102  *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)
4103  | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));
4104  sp++;
4105  }
4106  }
4107 
4108  else if (row_info->bit_depth == 8)
4109  {
4110  sp = row;
4111  for (i = 0; i < row_width; i++)
4112  {
4113  *sp = gamma_table[*sp];
4114  sp++;
4115  }
4116  }
4117 
4118  else if (row_info->bit_depth == 16)
4119  {
4120  sp = row;
4121  for (i = 0; i < row_width; i++)
4122  {
4123  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
4124  *sp = (png_byte)((v >> 8) & 0xff);
4125  *(sp + 1) = (png_byte)(v & 0xff);
4126  sp += 2;
4127  }
4128  }
4129  break;
4130  }
4131 
4132  default:
4133  break;
4134  }
4135  }
4136 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_do_encode_alpha()

static void png_do_encode_alpha ( png_row_infop  row_info,
png_bytep  row,
png_structrp  png_ptr 
)
static
4146 {
4147  png_uint_32 row_width = row_info->width;
4148 
4149  png_debug(1, "in png_do_encode_alpha");
4150 
4151  if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
4152  {
4153  if (row_info->bit_depth == 8)
4154  {
4155  png_bytep table = png_ptr->gamma_from_1;
4156 
4157  if (table != NULL)
4158  {
4159  int step = (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2;
4160 
4161  /* The alpha channel is the last component: */
4162  row += step - 1;
4163 
4164  for (; row_width > 0; --row_width, row += step)
4165  *row = table[*row];
4166 
4167  return;
4168  }
4169  }
4170 
4171  else if (row_info->bit_depth == 16)
4172  {
4173  png_uint_16pp table = png_ptr->gamma_16_from_1;
4174  int gamma_shift = png_ptr->gamma_shift;
4175 
4176  if (table != NULL)
4177  {
4178  int step = (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4;
4179 
4180  /* The alpha channel is the last component: */
4181  row += step - 2;
4182 
4183  for (; row_width > 0; --row_width, row += step)
4184  {
4185  png_uint_16 v;
4186 
4187  v = table[*(row + 1) >> gamma_shift][*row];
4188  *row = (png_byte)((v >> 8) & 0xff);
4189  *(row + 1) = (png_byte)(v & 0xff);
4190  }
4191 
4192  return;
4193  }
4194  }
4195  }
4196 
4197  /* Only get to here if called with a weird row_info; no harm has been done,
4198  * so just issue a warning.
4199  */
4200  png_warning(png_ptr, "png_do_encode_alpha: unexpected call");
4201 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ png_do_expand_palette()

static void png_do_expand_palette ( png_structrp  png_ptr,
png_row_infop  row_info,
png_bytep  row,
png_const_colorp  palette,
png_const_bytep  trans_alpha,
int  num_trans 
)
static
4212 {
4213  int shift, value;
4214  png_bytep sp, dp;
4215  png_uint_32 i;
4216  png_uint_32 row_width=row_info->width;
4217 
4218  png_debug(1, "in png_do_expand_palette");
4219 
4220  if (row_info->color_type == PNG_COLOR_TYPE_PALETTE)
4221  {
4222  if (row_info->bit_depth < 8)
4223  {
4224  switch (row_info->bit_depth)
4225  {
4226  case 1:
4227  {
4228  sp = row + (size_t)((row_width - 1) >> 3);
4229  dp = row + (size_t)row_width - 1;
4230  shift = 7 - (int)((row_width + 7) & 0x07);
4231  for (i = 0; i < row_width; i++)
4232  {
4233  if ((*sp >> shift) & 0x01)
4234  *dp = 1;
4235 
4236  else
4237  *dp = 0;
4238 
4239  if (shift == 7)
4240  {
4241  shift = 0;
4242  sp--;
4243  }
4244 
4245  else
4246  shift++;
4247 
4248  dp--;
4249  }
4250  break;
4251  }
4252 
4253  case 2:
4254  {
4255  sp = row + (size_t)((row_width - 1) >> 2);
4256  dp = row + (size_t)row_width - 1;
4257  shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
4258  for (i = 0; i < row_width; i++)
4259  {
4260  value = (*sp >> shift) & 0x03;
4261  *dp = (png_byte)value;
4262  if (shift == 6)
4263  {
4264  shift = 0;
4265  sp--;
4266  }
4267 
4268  else
4269  shift += 2;
4270 
4271  dp--;
4272  }
4273  break;
4274  }
4275 
4276  case 4:
4277  {
4278  sp = row + (size_t)((row_width - 1) >> 1);
4279  dp = row + (size_t)row_width - 1;
4280  shift = (int)((row_width & 0x01) << 2);
4281  for (i = 0; i < row_width; i++)
4282  {
4283  value = (*sp >> shift) & 0x0f;
4284  *dp = (png_byte)value;
4285  if (shift == 4)
4286  {
4287  shift = 0;
4288  sp--;
4289  }
4290 
4291  else
4292  shift += 4;
4293 
4294  dp--;
4295  }
4296  break;
4297  }
4298 
4299  default:
4300  break;
4301  }
4302  row_info->bit_depth = 8;
4303  row_info->pixel_depth = 8;
4304  row_info->rowbytes = row_width;
4305  }
4306 
4307  if (row_info->bit_depth == 8)
4308  {
4309  {
4310  if (num_trans > 0)
4311  {
4312  sp = row + (size_t)row_width - 1;
4313  dp = row + ((size_t)row_width << 2) - 1;
4314 
4315  i = 0;
4316 #ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE
4317  if (png_ptr->riffled_palette != NULL)
4318  {
4319  /* The RGBA optimization works with png_ptr->bit_depth == 8
4320  * but sometimes row_info->bit_depth has been changed to 8.
4321  * In these cases, the palette hasn't been riffled.
4322  */
4323  i = png_do_expand_palette_neon_rgba(png_ptr, row_info, row,
4324  &sp, &dp);
4325  }
4326 #endif
4327 
4328  for (; i < row_width; i++)
4329  {
4330  if ((int)(*sp) >= num_trans)
4331  *dp-- = 0xff;
4332  else
4333  *dp-- = trans_alpha[*sp];
4334  *dp-- = palette[*sp].blue;
4335  *dp-- = palette[*sp].green;
4336  *dp-- = palette[*sp].red;
4337  sp--;
4338  }
4339  row_info->bit_depth = 8;
4340  row_info->pixel_depth = 32;
4341  row_info->rowbytes = row_width * 4;
4342  row_info->color_type = 6;
4343  row_info->channels = 4;
4344  }
4345 
4346  else
4347  {
4348  sp = row + (size_t)row_width - 1;
4349  dp = row + (size_t)(row_width * 3) - 1;
4350  i = 0;
4351 #ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE
4352  i = png_do_expand_palette_neon_rgb(png_ptr, row_info, row,
4353  &sp, &dp);
4354 #endif
4355 
4356  for (; i < row_width; i++)
4357  {
4358  *dp-- = palette[*sp].blue;
4359  *dp-- = palette[*sp].green;
4360  *dp-- = palette[*sp].red;
4361  sp--;
4362  }
4363 
4364  row_info->bit_depth = 8;
4365  row_info->pixel_depth = 24;
4366  row_info->rowbytes = row_width * 3;
4367  row_info->color_type = 2;
4368  row_info->channels = 3;
4369  }
4370  }
4371  }
4372  }
4373 }
Here is the caller graph for this function:

◆ png_do_expand()

static void png_do_expand ( png_row_infop  row_info,
png_bytep  row,
png_const_color_16p  trans_color 
)
static
4381 {
4382  int shift, value;
4383  png_bytep sp, dp;
4384  png_uint_32 i;
4385  png_uint_32 row_width=row_info->width;
4386 
4387  png_debug(1, "in png_do_expand");
4388 
4389  if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
4390  {
4391  unsigned int gray = trans_color != NULL ? trans_color->gray : 0;
4392 
4393  if (row_info->bit_depth < 8)
4394  {
4395  switch (row_info->bit_depth)
4396  {
4397  case 1:
4398  {
4399  gray = (gray & 0x01) * 0xff;
4400  sp = row + (size_t)((row_width - 1) >> 3);
4401  dp = row + (size_t)row_width - 1;
4402  shift = 7 - (int)((row_width + 7) & 0x07);
4403  for (i = 0; i < row_width; i++)
4404  {
4405  if ((*sp >> shift) & 0x01)
4406  *dp = 0xff;
4407 
4408  else
4409  *dp = 0;
4410 
4411  if (shift == 7)
4412  {
4413  shift = 0;
4414  sp--;
4415  }
4416 
4417  else
4418  shift++;
4419 
4420  dp--;
4421  }
4422  break;
4423  }
4424 
4425  case 2:
4426  {
4427  gray = (gray & 0x03) * 0x55;
4428  sp = row + (size_t)((row_width - 1) >> 2);
4429  dp = row + (size_t)row_width - 1;
4430  shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
4431  for (i = 0; i < row_width; i++)
4432  {
4433  value = (*sp >> shift) & 0x03;
4434  *dp = (png_byte)(value | (value << 2) | (value << 4) |
4435  (value << 6));
4436  if (shift == 6)
4437  {
4438  shift = 0;
4439  sp--;
4440  }
4441 
4442  else
4443  shift += 2;
4444 
4445  dp--;
4446  }
4447  break;
4448  }
4449 
4450  case 4:
4451  {
4452  gray = (gray & 0x0f) * 0x11;
4453  sp = row + (size_t)((row_width - 1) >> 1);
4454  dp = row + (size_t)row_width - 1;
4455  shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
4456  for (i = 0; i < row_width; i++)
4457  {
4458  value = (*sp >> shift) & 0x0f;
4459  *dp = (png_byte)(value | (value << 4));
4460  if (shift == 4)
4461  {
4462  shift = 0;
4463  sp--;
4464  }
4465 
4466  else
4467  shift = 4;
4468 
4469  dp--;
4470  }
4471  break;
4472  }
4473 
4474  default:
4475  break;
4476  }
4477 
4478  row_info->bit_depth = 8;
4479  row_info->pixel_depth = 8;
4480  row_info->rowbytes = row_width;
4481  }
4482 
4483  if (trans_color != NULL)
4484  {
4485  if (row_info->bit_depth == 8)
4486  {
4487  gray = gray & 0xff;
4488  sp = row + (size_t)row_width - 1;
4489  dp = row + ((size_t)row_width << 1) - 1;
4490 
4491  for (i = 0; i < row_width; i++)
4492  {
4493  if ((*sp & 0xffU) == gray)
4494  *dp-- = 0;
4495 
4496  else
4497  *dp-- = 0xff;
4498 
4499  *dp-- = *sp--;
4500  }
4501  }
4502 
4503  else if (row_info->bit_depth == 16)
4504  {
4505  unsigned int gray_high = (gray >> 8) & 0xff;
4506  unsigned int gray_low = gray & 0xff;
4507  sp = row + row_info->rowbytes - 1;
4508  dp = row + (row_info->rowbytes << 1) - 1;
4509  for (i = 0; i < row_width; i++)
4510  {
4511  if ((*(sp - 1) & 0xffU) == gray_high &&
4512  (*(sp) & 0xffU) == gray_low)
4513  {
4514  *dp-- = 0;
4515  *dp-- = 0;
4516  }
4517 
4518  else
4519  {
4520  *dp-- = 0xff;
4521  *dp-- = 0xff;
4522  }
4523 
4524  *dp-- = *sp--;
4525  *dp-- = *sp--;
4526  }
4527  }
4528 
4529  row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
4530  row_info->channels = 2;
4531  row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
4532  row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
4533  row_width);
4534  }
4535  }
4536  else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
4537  trans_color != NULL)
4538  {
4539  if (row_info->bit_depth == 8)
4540  {
4541  png_byte red = (png_byte)(trans_color->red & 0xff);
4542  png_byte green = (png_byte)(trans_color->green & 0xff);
4543  png_byte blue = (png_byte)(trans_color->blue & 0xff);
4544  sp = row + (size_t)row_info->rowbytes - 1;
4545  dp = row + ((size_t)row_width << 2) - 1;
4546  for (i = 0; i < row_width; i++)
4547  {
4548  if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
4549  *dp-- = 0;
4550 
4551  else
4552  *dp-- = 0xff;
4553 
4554  *dp-- = *sp--;
4555  *dp-- = *sp--;
4556  *dp-- = *sp--;
4557  }
4558  }
4559  else if (row_info->bit_depth == 16)
4560  {
4561  png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff);
4562  png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff);
4563  png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff);
4564  png_byte red_low = (png_byte)(trans_color->red & 0xff);
4565  png_byte green_low = (png_byte)(trans_color->green & 0xff);
4566  png_byte blue_low = (png_byte)(trans_color->blue & 0xff);
4567  sp = row + row_info->rowbytes - 1;
4568  dp = row + ((size_t)row_width << 3) - 1;
4569  for (i = 0; i < row_width; i++)
4570  {
4571  if (*(sp - 5) == red_high &&
4572  *(sp - 4) == red_low &&
4573  *(sp - 3) == green_high &&
4574  *(sp - 2) == green_low &&
4575  *(sp - 1) == blue_high &&
4576  *(sp ) == blue_low)
4577  {
4578  *dp-- = 0;
4579  *dp-- = 0;
4580  }
4581 
4582  else
4583  {
4584  *dp-- = 0xff;
4585  *dp-- = 0xff;
4586  }
4587 
4588  *dp-- = *sp--;
4589  *dp-- = *sp--;
4590  *dp-- = *sp--;
4591  *dp-- = *sp--;
4592  *dp-- = *sp--;
4593  *dp-- = *sp--;
4594  }
4595  }
4596  row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
4597  row_info->channels = 4;
4598  row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
4599  row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
4600  }
4601 }
Here is the caller graph for this function:

◆ png_do_expand_16()

static void png_do_expand_16 ( png_row_infop  row_info,
png_bytep  row 
)
static
4610 {
4611  if (row_info->bit_depth == 8 &&
4612  row_info->color_type != PNG_COLOR_TYPE_PALETTE)
4613  {
4614  /* The row have a sequence of bytes containing [0..255] and we need
4615  * to turn it into another row containing [0..65535], to do this we
4616  * calculate:
4617  *
4618  * (input / 255) * 65535
4619  *
4620  * Which happens to be exactly input * 257 and this can be achieved
4621  * simply by byte replication in place (copying backwards).
4622  */
4623  png_byte *sp = row + row_info->rowbytes; /* source, last byte + 1 */
4624  png_byte *dp = sp + row_info->rowbytes; /* destination, end + 1 */
4625  while (dp > sp)
4626  {
4627  dp[-2] = dp[-1] = *--sp; dp -= 2;
4628  }
4629 
4630  row_info->rowbytes *= 2;
4631  row_info->bit_depth = 16;
4632  row_info->pixel_depth = (png_byte)(row_info->channels * 16);
4633  }
4634 }
Here is the caller graph for this function:

◆ png_do_quantize()

static void png_do_quantize ( png_row_infop  row_info,
png_bytep  row,
png_const_bytep  palette_lookup,
png_const_bytep  quantize_lookup 
)
static
4641 {
4642  png_bytep sp, dp;
4643  png_uint_32 i;
4644  png_uint_32 row_width=row_info->width;
4645 
4646  png_debug(1, "in png_do_quantize");
4647 
4648  if (row_info->bit_depth == 8)
4649  {
4650  if (row_info->color_type == PNG_COLOR_TYPE_RGB && palette_lookup)
4651  {
4652  int r, g, b, p;
4653  sp = row;
4654  dp = row;
4655  for (i = 0; i < row_width; i++)
4656  {
4657  r = *sp++;
4658  g = *sp++;
4659  b = *sp++;
4660 
4661  /* This looks real messy, but the compiler will reduce
4662  * it down to a reasonable formula. For example, with
4663  * 5 bits per color, we get:
4664  * p = (((r >> 3) & 0x1f) << 10) |
4665  * (((g >> 3) & 0x1f) << 5) |
4666  * ((b >> 3) & 0x1f);
4667  */
4668  p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) &
4669  ((1 << PNG_QUANTIZE_RED_BITS) - 1)) <<
4670  (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) |
4671  (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) &
4672  ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) <<
4673  (PNG_QUANTIZE_BLUE_BITS)) |
4674  ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) &
4675  ((1 << PNG_QUANTIZE_BLUE_BITS) - 1));
4676 
4677  *dp++ = palette_lookup[p];
4678  }
4679 
4680  row_info->color_type = PNG_COLOR_TYPE_PALETTE;
4681  row_info->channels = 1;
4682  row_info->pixel_depth = row_info->bit_depth;
4683  row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
4684  }
4685 
4686  else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
4687  palette_lookup != NULL)
4688  {
4689  int r, g, b, p;
4690  sp = row;
4691  dp = row;
4692  for (i = 0; i < row_width; i++)
4693  {
4694  r = *sp++;
4695  g = *sp++;
4696  b = *sp++;
4697  sp++;
4698 
4699  p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) &
4700  ((1 << PNG_QUANTIZE_RED_BITS) - 1)) <<
4701  (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) |
4702  (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) &
4703  ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) <<
4704  (PNG_QUANTIZE_BLUE_BITS)) |
4705  ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) &
4706  ((1 << PNG_QUANTIZE_BLUE_BITS) - 1));
4707 
4708  *dp++ = palette_lookup[p];
4709  }
4710 
4711  row_info->color_type = PNG_COLOR_TYPE_PALETTE;
4712  row_info->channels = 1;
4713  row_info->pixel_depth = row_info->bit_depth;
4714  row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
4715  }
4716 
4717  else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
4718  quantize_lookup)
4719  {
4720  sp = row;
4721 
4722  for (i = 0; i < row_width; i++, sp++)
4723  {
4724  *sp = quantize_lookup[*sp];
4725  }
4726  }
4727  }
4728 }
Here is the caller graph for this function:

◆ png_do_read_transformations()

void png_do_read_transformations ( png_structrp  png_ptr,
png_row_infop  row_info 
)
4737 {
4738  png_debug(1, "in png_do_read_transformations");
4739 
4740  if (png_ptr->row_buf == NULL)
4741  {
4742  /* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this
4743  * error is incredibly rare and incredibly easy to debug without this
4744  * information.
4745  */
4746  png_error(png_ptr, "NULL row buffer");
4747  }
4748 
4749  /* The following is debugging; prior to 1.5.4 the code was never compiled in;
4750  * in 1.5.4 PNG_FLAG_DETECT_UNINITIALIZED was added and the macro
4751  * PNG_WARN_UNINITIALIZED_ROW removed. In 1.6 the new flag is set only for
4752  * all transformations, however in practice the ROW_INIT always gets done on
4753  * demand, if necessary.
4754  */
4755  if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 &&
4756  (png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
4757  {
4758  /* Application has failed to call either png_read_start_image() or
4759  * png_read_update_info() after setting transforms that expand pixels.
4760  * This check added to libpng-1.2.19 (but not enabled until 1.5.4).
4761  */
4762  png_error(png_ptr, "Uninitialized row");
4763  }
4764 
4765 #ifdef PNG_READ_EXPAND_SUPPORTED
4766  if ((png_ptr->transformations & PNG_EXPAND) != 0)
4767  {
4768  if (row_info->color_type == PNG_COLOR_TYPE_PALETTE)
4769  {
4770 #ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE
4771  if ((png_ptr->num_trans > 0) && (png_ptr->bit_depth == 8))
4772  {
4773  /* Allocate space for the decompressed full palette. */
4774  if (png_ptr->riffled_palette == NULL)
4775  {
4776  png_ptr->riffled_palette = png_malloc(png_ptr, 256*4);
4777  if (png_ptr->riffled_palette == NULL)
4778  png_error(png_ptr, "NULL row buffer");
4779  /* Build the RGBA palette. */
4780  png_riffle_palette_rgba(png_ptr, row_info);
4781  }
4782  }
4783 #endif
4784  png_do_expand_palette(png_ptr, row_info, png_ptr->row_buf + 1,
4785  png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
4786  }
4787 
4788  else
4789  {
4790  if (png_ptr->num_trans != 0 &&
4791  (png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
4792  png_do_expand(row_info, png_ptr->row_buf + 1,
4793  &(png_ptr->trans_color));
4794 
4795  else
4796  png_do_expand(row_info, png_ptr->row_buf + 1, NULL);
4797  }
4798  }
4799 #endif
4800 
4801 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
4802  if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
4803  (png_ptr->transformations & PNG_COMPOSE) == 0 &&
4804  (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
4805  row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
4806  png_do_strip_channel(row_info, png_ptr->row_buf + 1,
4807  0 /* at_start == false, because SWAP_ALPHA happens later */);
4808 #endif
4809 
4810 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
4811  if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
4812  {
4813  int rgb_error =
4814  png_do_rgb_to_gray(png_ptr, row_info,
4815  png_ptr->row_buf + 1);
4816 
4817  if (rgb_error != 0)
4818  {
4819  png_ptr->rgb_to_gray_status=1;
4820  if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
4821  PNG_RGB_TO_GRAY_WARN)
4822  png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
4823 
4824  if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
4825  PNG_RGB_TO_GRAY_ERR)
4826  png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
4827  }
4828  }
4829 #endif
4830 
4831 /* From Andreas Dilger e-mail to png-implement, 26 March 1998:
4832  *
4833  * In most cases, the "simple transparency" should be done prior to doing
4834  * gray-to-RGB, or you will have to test 3x as many bytes to check if a
4835  * pixel is transparent. You would also need to make sure that the
4836  * transparency information is upgraded to RGB.
4837  *
4838  * To summarize, the current flow is:
4839  * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
4840  * with background "in place" if transparent,
4841  * convert to RGB if necessary
4842  * - Gray + alpha -> composite with gray background and remove alpha bytes,
4843  * convert to RGB if necessary
4844  *
4845  * To support RGB backgrounds for gray images we need:
4846  * - Gray + simple transparency -> convert to RGB + simple transparency,
4847  * compare 3 or 6 bytes and composite with
4848  * background "in place" if transparent
4849  * (3x compare/pixel compared to doing
4850  * composite with gray bkgrnd)
4851  * - Gray + alpha -> convert to RGB + alpha, composite with background and
4852  * remove alpha bytes (3x float
4853  * operations/pixel compared with composite
4854  * on gray background)
4855  *
4856  * Greg's change will do this. The reason it wasn't done before is for
4857  * performance, as this increases the per-pixel operations. If we would check
4858  * in advance if the background was gray or RGB, and position the gray-to-RGB
4859  * transform appropriately, then it would save a lot of work/time.
4860  */
4861 
4862 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
4863  /* If gray -> RGB, do so now only if background is non-gray; else do later
4864  * for performance reasons
4865  */
4866  if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
4867  (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) == 0)
4868  png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
4869 #endif
4870 
4871 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
4872  defined(PNG_READ_ALPHA_MODE_SUPPORTED)
4873  if ((png_ptr->transformations & PNG_COMPOSE) != 0)
4874  png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr);
4875 #endif
4876 
4877 #ifdef PNG_READ_GAMMA_SUPPORTED
4878  if ((png_ptr->transformations & PNG_GAMMA) != 0 &&
4879 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
4880  /* Because RGB_TO_GRAY does the gamma transform. */
4881  (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0 &&
4882 #endif
4883 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
4884  defined(PNG_READ_ALPHA_MODE_SUPPORTED)
4885  /* Because PNG_COMPOSE does the gamma transform if there is something to
4886  * do (if there is an alpha channel or transparency.)
4887  */
4888  !((png_ptr->transformations & PNG_COMPOSE) != 0 &&
4889  ((png_ptr->num_trans != 0) ||
4890  (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)) &&
4891 #endif
4892  /* Because png_init_read_transformations transforms the palette, unless
4893  * RGB_TO_GRAY will do the transform.
4894  */
4895  (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
4896  png_do_gamma(row_info, png_ptr->row_buf + 1, png_ptr);
4897 #endif
4898 
4899 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
4900  if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
4901  (png_ptr->transformations & PNG_COMPOSE) != 0 &&
4902  (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
4903  row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
4904  png_do_strip_channel(row_info, png_ptr->row_buf + 1,
4905  0 /* at_start == false, because SWAP_ALPHA happens later */);
4906 #endif
4907 
4908 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
4909  if ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
4910  (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
4911  png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr);
4912 #endif
4913 
4914 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
4915  if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
4916  png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1);
4917 #endif
4918 
4919 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
4920  /* There is no harm in doing both of these because only one has any effect,
4921  * by putting the 'scale' option first if the app asks for scale (either by
4922  * calling the API or in a TRANSFORM flag) this is what happens.
4923  */
4924  if ((png_ptr->transformations & PNG_16_TO_8) != 0)
4925  png_do_chop(row_info, png_ptr->row_buf + 1);
4926 #endif
4927 
4928 #ifdef PNG_READ_QUANTIZE_SUPPORTED
4929  if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
4930  {
4931  png_do_quantize(row_info, png_ptr->row_buf + 1,
4932  png_ptr->palette_lookup, png_ptr->quantize_index);
4933 
4934  if (row_info->rowbytes == 0)
4935  png_error(png_ptr, "png_do_quantize returned rowbytes=0");
4936  }
4937 #endif /* READ_QUANTIZE */
4938 
4939 #ifdef PNG_READ_EXPAND_16_SUPPORTED
4940  /* Do the expansion now, after all the arithmetic has been done. Notice
4941  * that previous transformations can handle the PNG_EXPAND_16 flag if this
4942  * is efficient (particularly true in the case of gamma correction, where
4943  * better accuracy results faster!)
4944  */
4945  if ((png_ptr->transformations & PNG_EXPAND_16) != 0)
4946  png_do_expand_16(row_info, png_ptr->row_buf + 1);
4947 #endif
4948 
4949 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
4950  /* NOTE: moved here in 1.5.4 (from much later in this list.) */
4951  if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
4952  (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) != 0)
4953  png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
4954 #endif
4955 
4956 #ifdef PNG_READ_INVERT_SUPPORTED
4957  if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
4958  png_do_invert(row_info, png_ptr->row_buf + 1);
4959 #endif
4960 
4961 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
4962  if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
4963  png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1);
4964 #endif
4965 
4966 #ifdef PNG_READ_SHIFT_SUPPORTED
4967  if ((png_ptr->transformations & PNG_SHIFT) != 0)
4968  png_do_unshift(row_info, png_ptr->row_buf + 1,
4969  &(png_ptr->shift));
4970 #endif
4971 
4972 #ifdef PNG_READ_PACK_SUPPORTED
4973  if ((png_ptr->transformations & PNG_PACK) != 0)
4974  png_do_unpack(row_info, png_ptr->row_buf + 1);
4975 #endif
4976 
4977 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
4978  /* Added at libpng-1.5.10 */
4979  if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
4980  png_ptr->num_palette_max >= 0)
4981  png_do_check_palette_indexes(png_ptr, row_info);
4982 #endif
4983 
4984 #ifdef PNG_READ_BGR_SUPPORTED
4985  if ((png_ptr->transformations & PNG_BGR) != 0)
4986  png_do_bgr(row_info, png_ptr->row_buf + 1);
4987 #endif
4988 
4989 #ifdef PNG_READ_PACKSWAP_SUPPORTED
4990  if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
4991  png_do_packswap(row_info, png_ptr->row_buf + 1);
4992 #endif
4993 
4994 #ifdef PNG_READ_FILLER_SUPPORTED
4995  if ((png_ptr->transformations & PNG_FILLER) != 0)
4996  png_do_read_filler(row_info, png_ptr->row_buf + 1,
4997  (png_uint_32)png_ptr->filler, png_ptr->flags);
4998 #endif
4999 
5000 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
5001  if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
5002  png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1);
5003 #endif
5004 
5005 #ifdef PNG_READ_16BIT_SUPPORTED
5006 #ifdef PNG_READ_SWAP_SUPPORTED
5007  if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
5008  png_do_swap(row_info, png_ptr->row_buf + 1);
5009 #endif
5010 #endif
5011 
5012 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
5013  if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
5014  {
5015  if (png_ptr->read_user_transform_fn != NULL)
5016  (*(png_ptr->read_user_transform_fn)) /* User read transform function */
5017  (png_ptr, /* png_ptr */
5018  row_info, /* row_info: */
5019  /* png_uint_32 width; width of row */
5020  /* size_t rowbytes; number of bytes in row */
5021  /* png_byte color_type; color type of pixels */
5022  /* png_byte bit_depth; bit depth of samples */
5023  /* png_byte channels; number of channels (1-4) */
5024  /* png_byte pixel_depth; bits per pixel (depth*channels) */
5025  png_ptr->row_buf + 1); /* start of pixel data for row */
5026 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
5027  if (png_ptr->user_transform_depth != 0)
5028  row_info->bit_depth = png_ptr->user_transform_depth;
5029 
5030  if (png_ptr->user_transform_channels != 0)
5031  row_info->channels = png_ptr->user_transform_channels;
5032 #endif
5033  row_info->pixel_depth = (png_byte)(row_info->bit_depth *
5034  row_info->channels);
5035 
5036  row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->width);
5037  }
5038 #endif
5039 }
Here is the call graph for this function:
Here is the caller graph for this function:
PNG_BGR
#define PNG_BGR
Definition: pngpriv.h:642
PNG_SCALE_16_TO_8
#define PNG_SCALE_16_TO_8
Definition: pngpriv.h:669
png_const_bytep
const typedef png_byte * png_const_bytep
Definition: pngconf.h:580
png_do_chop
static void png_do_chop(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2450
PNG_FP_MIN
#define PNG_FP_MIN
Definition: png.h:659
PNG_QUANTIZE_BLUE_BITS
#define PNG_QUANTIZE_BLUE_BITS
Definition: pnglibconf.h:202
PNG_16_TO_8
#define PNG_16_TO_8
Definition: pngpriv.h:652
PNG_QUANTIZE_GREEN_BITS
#define PNG_QUANTIZE_GREEN_BITS
Definition: pnglibconf.h:203
PNG_EXPAND
#define PNG_EXPAND
Definition: pngpriv.h:654
png_set_background_fixed
void PNGFAPI png_set_background_fixed(png_structrp png_ptr, png_const_color_16p background_color, int background_gamma_code, int need_expand, png_fixed_point background_gamma)
Definition: pngrtran.c:137
PNG_GAMMA_MAC_18
#define PNG_GAMMA_MAC_18
Definition: png.h:1148
png_reciprocal
png_fixed_point png_reciprocal(png_fixed_point a)
Definition: png.c:3488
PNG_UNUSED
#define PNG_UNUSED(param)
Definition: pngpriv.h:438
png_dsort_struct::next
struct png_dsort_struct * next
Definition: pngrtran.c:420
png_build_gamma_table
void png_build_gamma_table(png_structrp png_ptr, int bit_depth)
Definition: png.c:4196
PNG_DEFAULT_sRGB
#define PNG_DEFAULT_sRGB
Definition: png.h:1147
PNG_INVERT_ALPHA
#define PNG_INVERT_ALPHA
Definition: pngpriv.h:661
png_do_gamma
static void png_do_gamma(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
Definition: pngrtran.c:3944
PNG_CRC_ERROR_QUIT
#define PNG_CRC_ERROR_QUIT
Definition: png.h:1437
png_fixed
png_fixed_point png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)
Definition: png.c:3316
error_action
png_structrp int error_action
Definition: png.h:1083
png_gamma_threshold
static int png_gamma_threshold(png_fixed_point screen_gamma, png_fixed_point file_gamma)
Definition: pngrtran.c:1092
PNG_BACKGROUND_EXPAND
#define PNG_BACKGROUND_EXPAND
Definition: pngpriv.h:650
png_free
void PNGAPI png_free(png_const_structrp png_ptr, png_voidp ptr)
Definition: pngmem.c:232
PNG_COLOR_DIST
#define PNG_COLOR_DIST(c1, c2)
Definition: pngpriv.h:722
convert_gamma_value
static png_fixed_point convert_gamma_value(png_structrp png_ptr, double output_gamma)
Definition: pngrtran.c:262
png_dsort
struct png_dsort_struct png_dsort
PNG_RGB_TO_GRAY_ERR
#define PNG_RGB_TO_GRAY_ERR
Definition: pngpriv.h:663
PNG_GAMMA_sRGB
#define PNG_GAMMA_sRGB
Definition: png.h:1149
PNG_GRAY_TO_RGB
#define PNG_GRAY_TO_RGB
Definition: pngpriv.h:656
PNG_BACKGROUND_GAMMA_UNIQUE
#define PNG_BACKGROUND_GAMMA_UNIQUE
Definition: png.h:1310
PNG_COMPOSE
#define PNG_COMPOSE
Definition: pngpriv.h:649
PNG_READ_ALPHA_MODE_SUPPORTED
#define PNG_READ_ALPHA_MODE_SUPPORTED
Definition: pnglibconf.h:50
PNG_FLAG_ROW_INIT
#define PNG_FLAG_ROW_INIT
Definition: pngpriv.h:685
PNG_EXPAND_tRNS
#define PNG_EXPAND_tRNS
Definition: pngpriv.h:668
png_bytep
png_byte * png_bytep
Definition: pngconf.h:579
i
uint8_t i
Definition: screen_test_graph.c:72
PNG_ALPHA_ASSOCIATED
#define PNG_ALPHA_ASSOCIATED
Definition: png.h:1132
png_do_read_invert_alpha
static void png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2571
png_do_encode_alpha
static void png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
Definition: pngrtran.c:4145
png_gamma_correct
png_uint_16 png_gamma_correct(png_structrp png_ptr, unsigned int value, png_fixed_point gamma_val)
Definition: png.c:3947
PNG_INVERT_MONO
#define PNG_INVERT_MONO
Definition: pngpriv.h:647
PNG_ERROR_ACTION_WARN
#define PNG_ERROR_ACTION_WARN
Definition: png.h:1077
PNG_READ_FILLER_SUPPORTED
#define PNG_READ_FILLER_SUPPORTED
Definition: pnglibconf.h:59
PNG_COLOR_TYPE_RGB_ALPHA
#define PNG_COLOR_TYPE_RGB_ALPHA
Definition: png.h:671
PNG_GAMMA_MAC_OLD
#define PNG_GAMMA_MAC_OLD
Definition: pngpriv.h:904
PNG_FLAG_ASSUME_sRGB
#define PNG_FLAG_ASSUME_sRGB
Definition: pngpriv.h:691
need_expand
png_structrp png_const_color_16p int int need_expand
Definition: png.h:1302
PNG_FLAG_CRC_CRITICAL_IGNORE
#define PNG_FLAG_CRC_CRITICAL_IGNORE
Definition: pngpriv.h:690
PNG_GAMMA_MAC_INVERSE
#define PNG_GAMMA_MAC_INVERSE
Definition: pngpriv.h:905
png_do_unpack
static void png_do_unpack(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2152
png_init_palette_transformations
static void png_init_palette_transformations(png_structrp png_ptr)
Definition: pngrtran.c:1117
PNG_CRC_NO_CHANGE
#define PNG_CRC_NO_CHANGE
Definition: png.h:1441
NULL
#define NULL
Definition: usbd_def.h:53
png_row_info_struct::width
png_uint_32 width
Definition: png.h:756
png_dsortpp
png_dsort ** png_dsortpp
Definition: pngrtran.c:425
PNG_READ_STRIP_ALPHA_SUPPORTED
#define PNG_READ_STRIP_ALPHA_SUPPORTED
Definition: pnglibconf.h:75
png_ptr
png_structrp png_ptr
Definition: png.h:1083
png_dsortp
png_dsort * png_dsortp
Definition: pngrtran.c:424
PNG_COLOR_TYPE_RGB
#define PNG_COLOR_TYPE_RGB
Definition: png.h:670
info_ptr
png_const_structrp png_const_inforp info_ptr
Definition: png.h:1939
png_dsort_struct::right
png_byte right
Definition: pngrtran.c:422
translate_gamma_flags
static png_fixed_point translate_gamma_flags(png_structrp png_ptr, png_fixed_point output_gamma, int is_screen)
Definition: pngrtran.c:223
png_do_invert
void png_do_invert(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:262
PNG_SWAP_BYTES
#define PNG_SWAP_BYTES
Definition: pngpriv.h:646
png_do_check_palette_indexes
void png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
Definition: pngtrans.c:699
png_do_bgr
void png_do_bgr(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:619
png_uint_32
unsigned int png_uint_32
Definition: pngconf.h:511
png_uint_16
png_uint_16(PNGAPI png_get_uint_16)(png_const_bytep buf)
Definition: pngrutil.c:102
PNG_RGB_TO_GRAY_WARN
#define PNG_RGB_TO_GRAY_WARN
Definition: pngpriv.h:664
PNG_ALPHA_PNG
#define PNG_ALPHA_PNG
Definition: png.h:1130
png_do_read_swap_alpha
static void png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2475
PNG_HAVE_IHDR
#define PNG_HAVE_IHDR
Definition: png.h:644
PNG_PACKSWAP
#define PNG_PACKSWAP
Definition: pngpriv.h:658
PNG_FLAG_CRC_ANCILLARY_USE
#define PNG_FLAG_CRC_ANCILLARY_USE
Definition: pngpriv.h:687
red
png_structrp int png_fixed_point red
Definition: png.h:1083
png_row_info_struct::channels
png_byte channels
Definition: png.h:760
PNG_BACKGROUND_IS_GRAY
#define PNG_BACKGROUND_IS_GRAY
Definition: pngpriv.h:635
PNG_COLOR_TYPE_GRAY
#define PNG_COLOR_TYPE_GRAY
Definition: png.h:668
png_const_uint_16pp
const typedef png_uint_16p * png_const_uint_16pp
Definition: pngpriv.h:937
png_row_info_struct::color_type
png_byte color_type
Definition: png.h:758
png_color_struct::blue
png_byte blue
Definition: png.h:482
png_debug
#define png_debug(l, m)
Definition: pngdebug.h:145
png_do_compose
static void png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
Definition: pngrtran.c:3200
png_color_struct::green
png_byte green
Definition: png.h:481
PNG_CRC_WARN_DISCARD
#define PNG_CRC_WARN_DISCARD
Definition: png.h:1438
PNG_FLAG_DETECT_UNINITIALIZED
#define PNG_FLAG_DETECT_UNINITIALIZED
Definition: pngpriv.h:693
png_gamma_8bit_correct
png_byte png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
Definition: png.c:3864
PNG_FILLER
#define PNG_FILLER
Definition: pngpriv.h:657
png_muldiv
int png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, png_int_32 divisor)
Definition: png.c:3349
png_fixed_point
png_int_32 png_fixed_point
Definition: pngconf.h:574
PNG_QUANTIZE_RED_BITS
#define PNG_QUANTIZE_RED_BITS
Definition: pnglibconf.h:204
PNG_ERROR_ACTION_ERROR
#define PNG_ERROR_ACTION_ERROR
Definition: png.h:1078
png_color_struct
Definition: png.h:478
if
if(size<=((png_alloc_size_t) -1) - ob)
Definition: pngwrite.c:2176
PNG_CRC_DEFAULT
#define PNG_CRC_DEFAULT
Definition: png.h:1436
createSpeedLookupTable.a
list a
Definition: createSpeedLookupTable.py:29
png_row_info_struct::pixel_depth
png_byte pixel_depth
Definition: png.h:761
PNG_READ_RGB_TO_GRAY_SUPPORTED
#define PNG_READ_RGB_TO_GRAY_SUPPORTED
Definition: pnglibconf.h:71
PNG_ADD_ALPHA
#define PNG_ADD_ALPHA
Definition: pngpriv.h:667
png_do_swap
void png_do_swap(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:319
PNG_ALPHA_OPTIMIZED
#define PNG_ALPHA_OPTIMIZED
Definition: png.h:1134
png_composite
#define png_composite(composite, fg, alpha, bg)
Definition: png.h:2510
png_dsort_struct
Definition: pngrtran.c:418
png_uint_16pp
png_uint_16 ** png_uint_16pp
Definition: pngconf.h:609
png_colorspace_set_rgb_coefficients
void png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
Definition: png.c:2469
PNG_RGB_TO_GRAY
#define PNG_RGB_TO_GRAY
Definition: pngpriv.h:665
PNG_CRC_QUIET_USE
#define PNG_CRC_QUIET_USE
Definition: png.h:1440
PNG_FLAG_CRC_CRITICAL_USE
#define PNG_FLAG_CRC_CRITICAL_USE
Definition: pngpriv.h:689
CHOP
#define CHOP(x)
PNG_BACKGROUND_GAMMA_UNKNOWN
#define PNG_BACKGROUND_GAMMA_UNKNOWN
Definition: png.h:1307
png_error
else png_error(png_ptr, "png_image_write_to_memory: PNG too big")
png_do_scale_16_to_8
static void png_do_scale_16_to_8(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2389
png_reciprocal2
png_fixed_point png_reciprocal2(png_fixed_point a, png_fixed_point b)
Definition: png.c:3543
background_gamma_code
png_structrp png_const_color_16p int background_gamma_code
Definition: png.h:1302
PNG_BACKGROUND_GAMMA_SCREEN
#define PNG_BACKGROUND_GAMMA_SCREEN
Definition: png.h:1308
png_do_expand_16
static void png_do_expand_16(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:4609
png_do_expand_palette
static void png_do_expand_palette(png_structrp png_ptr, png_row_infop row_info, png_bytep row, png_const_colorp palette, png_const_bytep trans_alpha, int num_trans)
Definition: pngrtran.c:4209
PNG_ERROR_ACTION_NONE
#define PNG_ERROR_ACTION_NONE
Definition: png.h:1076
png_alloc_size_t
size_t png_alloc_size_t
Definition: pngconf.h:557
PNG_FLAG_CRC_ANCILLARY_NOWARN
#define PNG_FLAG_CRC_ANCILLARY_NOWARN
Definition: pngpriv.h:688
png_do_packswap
void png_do_packswap(png_row_infop row_info, png_bytep row)
Definition: pngtrans.c:455
png_do_read_filler
static void png_do_read_filler(png_row_infop row_info, png_bytep row, png_uint_32 filler, png_uint_32 flags)
Definition: pngrtran.c:2673
PNG_SHIFT
#define PNG_SHIFT
Definition: pngpriv.h:645
screen_gamma
png_structrp png_fixed_point screen_gamma
Definition: png.h:1352
PNG_BACKGROUND_GAMMA_FILE
#define PNG_BACKGROUND_GAMMA_FILE
Definition: png.h:1309
PNG_ROWBYTES
#define PNG_ROWBYTES(pixel_bits, width)
Definition: pngpriv.h:738
png_set_rgb_to_gray_fixed
void PNGFAPI png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action, png_fixed_point red, png_fixed_point green)
Definition: pngrtran.c:970
PNG_FLAG_FILLER_AFTER
#define PNG_FLAG_FILLER_AFTER
Definition: pngpriv.h:686
png_do_quantize
static void png_do_quantize(png_row_infop row_info, png_bytep row, png_const_bytep palette_lookup, png_const_bytep quantize_lookup)
Definition: pngrtran.c:4639
png_rtran_ok
static int png_rtran_ok(png_structrp png_ptr, int need_IHDR)
Definition: pngrtran.c:110
PNG_COLOR_MASK_COLOR
#define PNG_COLOR_MASK_COLOR
Definition: png.h:664
PNG_ALPHA_BROKEN
#define PNG_ALPHA_BROKEN
Definition: png.h:1135
png_set_gamma_fixed
void PNGFAPI png_set_gamma_fixed(png_structrp png_ptr, png_fixed_point scrn_gamma, png_fixed_point file_gamma)
Definition: pngrtran.c:818
png_do_unshift
static void png_do_unshift(png_row_infop row_info, png_bytep row, png_const_color_8p sig_bits)
Definition: pngrtran.c:2250
png_color_struct::red
png_byte red
Definition: png.h:480
createSpeedLookupTable.int
int
Definition: createSpeedLookupTable.py:15
png_gamma_significant
int png_gamma_significant(png_fixed_point gamma_val)
Definition: png.c:3509
PNG_READ_BACKGROUND_SUPPORTED
#define PNG_READ_BACKGROUND_SUPPORTED
Definition: pnglibconf.h:52
png_composite_16
#define png_composite_16(composite, fg, alpha, bg)
Definition: png.h:2519
PNG_FLAG_CRC_CRITICAL_MASK
#define PNG_FLAG_CRC_CRITICAL_MASK
Definition: pngpriv.h:714
PNG_PACK
#define PNG_PACK
Definition: pngpriv.h:644
PNG_FLAG_OPTIMIZE_ALPHA
#define PNG_FLAG_OPTIMIZE_ALPHA
Definition: pngpriv.h:692
PNG_FLAG_CRC_ANCILLARY_MASK
#define PNG_FLAG_CRC_ANCILLARY_MASK
Definition: pngpriv.h:711
PNG_COLOR_MASK_PALETTE
#define PNG_COLOR_MASK_PALETTE
Definition: png.h:663
png_set_alpha_mode_fixed
void PNGFAPI png_set_alpha_mode_fixed(png_structrp png_ptr, int mode, png_fixed_point output_gamma)
Definition: pngrtran.c:287
png_init_rgb_transformations
static void png_init_rgb_transformations(png_structrp png_ptr)
Definition: pngrtran.c:1206
PNG_QUANTIZE
#define PNG_QUANTIZE
Definition: pngpriv.h:648
background_color
png_structrp png_const_color_16p background_color
Definition: png.h:1302
png_do_expand
static void png_do_expand(png_row_infop row_info, png_bytep row, png_const_color_16p trans_color)
Definition: pngrtran.c:4379
PNG_STRIP_ALPHA
#define PNG_STRIP_ALPHA
Definition: pngpriv.h:660
PNG_FP_MAX
#define PNG_FP_MAX
Definition: png.h:658
PNG_GAMMA
#define PNG_GAMMA
Definition: pngpriv.h:655
mode
png_structrp int mode
Definition: png.h:1139
PNG_FP_1
#define PNG_FP_1
Definition: png.h:656
png_app_warning
void png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
Definition: pngerror.c:392
png_row_info_struct::rowbytes
size_t rowbytes
Definition: png.h:757
png_do_gray_to_rgb
static void png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2860
png_app_error
void png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
Definition: pngerror.c:405
PNG_CRC_WARN_USE
#define PNG_CRC_WARN_USE
Definition: png.h:1439
createSpeedLookupTable.b
list b
Definition: createSpeedLookupTable.py:30
png_row_info_struct::bit_depth
png_byte bit_depth
Definition: png.h:759
PNG_ENCODE_ALPHA
#define PNG_ENCODE_ALPHA
Definition: pngpriv.h:666
PNG_COLOR_TYPE_GRAY_ALPHA
#define PNG_COLOR_TYPE_GRAY_ALPHA
Definition: png.h:672
PNG_GAMMA_sRGB_INVERSE
#define PNG_GAMMA_sRGB_INVERSE
Definition: pngpriv.h:906
png_set_expand_gray_1_2_4_to_8
void PNGAPI png_set_expand_gray_1_2_4_to_8(png_structrp png_ptr)
Definition: pngrtran.c:914
png_warning
void PNGAPI png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:216
png_int_32
png_int_32(PNGAPI png_get_int_32)(png_const_bytep buf)
Definition: pngrutil.c:84
PNG_EXPAND_16
#define PNG_EXPAND_16
Definition: pngpriv.h:651
PNG_COLOR_MASK_ALPHA
#define PNG_COLOR_MASK_ALPHA
Definition: png.h:665
png_dsort_struct::left
png_byte left
Definition: pngrtran.c:421
PNG_COLOR_TYPE_PALETTE
#define PNG_COLOR_TYPE_PALETTE
Definition: png.h:669
PNG_SWAP_ALPHA
#define PNG_SWAP_ALPHA
Definition: pngpriv.h:659
png_do_rgb_to_gray
static int png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
Definition: pngrtran.c:2999
PNG_USER_TRANSFORM
#define PNG_USER_TRANSFORM
Definition: pngpriv.h:662
png_do_strip_channel
void png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
Definition: pngtrans.c:495