vrshoot

annotate libs/libpng/pngrtran.c @ 0:b2f14e535253

find changesets by author, revision, files, or words in the commit message
initial commit
author John Tsiombikas <nuclear@member.fsf.org>
date Sat, 01 Feb 2014 19:58:19 +0200
parents
children
rev   line source
nuclear@0 1
nuclear@0 2 /* pngrtran.c - transforms the data in a row for PNG readers
nuclear@0 3 *
nuclear@0 4 * Last changed in libpng 1.2.30 [August 15, 2008]
nuclear@0 5 * For conditions of distribution and use, see copyright notice in png.h
nuclear@0 6 * Copyright (c) 1998-2008 Glenn Randers-Pehrson
nuclear@0 7 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
nuclear@0 8 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
nuclear@0 9 *
nuclear@0 10 * This file contains functions optionally called by an application
nuclear@0 11 * in order to tell libpng how to handle data when reading a PNG.
nuclear@0 12 * Transformations that are used in both reading and writing are
nuclear@0 13 * in pngtrans.c.
nuclear@0 14 */
nuclear@0 15
nuclear@0 16 #define PNG_INTERNAL
nuclear@0 17 #include "png.h"
nuclear@0 18 #if defined(PNG_READ_SUPPORTED)
nuclear@0 19
nuclear@0 20 /* Set the action on getting a CRC error for an ancillary or critical chunk. */
nuclear@0 21 void PNGAPI
nuclear@0 22 png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
nuclear@0 23 {
nuclear@0 24 png_debug(1, "in png_set_crc_action\n");
nuclear@0 25 /* Tell libpng how we react to CRC errors in critical chunks */
nuclear@0 26 if (png_ptr == NULL) return;
nuclear@0 27 switch (crit_action)
nuclear@0 28 {
nuclear@0 29 case PNG_CRC_NO_CHANGE: /* leave setting as is */
nuclear@0 30 break;
nuclear@0 31 case PNG_CRC_WARN_USE: /* warn/use data */
nuclear@0 32 png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
nuclear@0 33 png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
nuclear@0 34 break;
nuclear@0 35 case PNG_CRC_QUIET_USE: /* quiet/use data */
nuclear@0 36 png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
nuclear@0 37 png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
nuclear@0 38 PNG_FLAG_CRC_CRITICAL_IGNORE;
nuclear@0 39 break;
nuclear@0 40 case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */
nuclear@0 41 png_warning(png_ptr,
nuclear@0 42 "Can't discard critical data on CRC error.");
nuclear@0 43 case PNG_CRC_ERROR_QUIT: /* error/quit */
nuclear@0 44 case PNG_CRC_DEFAULT:
nuclear@0 45 default:
nuclear@0 46 png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
nuclear@0 47 break;
nuclear@0 48 }
nuclear@0 49
nuclear@0 50 switch (ancil_action)
nuclear@0 51 {
nuclear@0 52 case PNG_CRC_NO_CHANGE: /* leave setting as is */
nuclear@0 53 break;
nuclear@0 54 case PNG_CRC_WARN_USE: /* warn/use data */
nuclear@0 55 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
nuclear@0 56 png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
nuclear@0 57 break;
nuclear@0 58 case PNG_CRC_QUIET_USE: /* quiet/use data */
nuclear@0 59 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
nuclear@0 60 png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
nuclear@0 61 PNG_FLAG_CRC_ANCILLARY_NOWARN;
nuclear@0 62 break;
nuclear@0 63 case PNG_CRC_ERROR_QUIT: /* error/quit */
nuclear@0 64 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
nuclear@0 65 png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
nuclear@0 66 break;
nuclear@0 67 case PNG_CRC_WARN_DISCARD: /* warn/discard data */
nuclear@0 68 case PNG_CRC_DEFAULT:
nuclear@0 69 default:
nuclear@0 70 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
nuclear@0 71 break;
nuclear@0 72 }
nuclear@0 73 }
nuclear@0 74
nuclear@0 75 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
nuclear@0 76 defined(PNG_FLOATING_POINT_SUPPORTED)
nuclear@0 77 /* handle alpha and tRNS via a background color */
nuclear@0 78 void PNGAPI
nuclear@0 79 png_set_background(png_structp png_ptr,
nuclear@0 80 png_color_16p background_color, int background_gamma_code,
nuclear@0 81 int need_expand, double background_gamma)
nuclear@0 82 {
nuclear@0 83 png_debug(1, "in png_set_background\n");
nuclear@0 84 if (png_ptr == NULL) return;
nuclear@0 85 if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
nuclear@0 86 {
nuclear@0 87 png_warning(png_ptr, "Application must supply a known background gamma");
nuclear@0 88 return;
nuclear@0 89 }
nuclear@0 90
nuclear@0 91 png_ptr->transformations |= PNG_BACKGROUND;
nuclear@0 92 png_memcpy(&(png_ptr->background), background_color,
nuclear@0 93 png_sizeof(png_color_16));
nuclear@0 94 png_ptr->background_gamma = (float)background_gamma;
nuclear@0 95 png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
nuclear@0 96 png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);
nuclear@0 97 }
nuclear@0 98 #endif
nuclear@0 99
nuclear@0 100 #if defined(PNG_READ_16_TO_8_SUPPORTED)
nuclear@0 101 /* strip 16 bit depth files to 8 bit depth */
nuclear@0 102 void PNGAPI
nuclear@0 103 png_set_strip_16(png_structp png_ptr)
nuclear@0 104 {
nuclear@0 105 png_debug(1, "in png_set_strip_16\n");
nuclear@0 106 if (png_ptr == NULL) return;
nuclear@0 107 png_ptr->transformations |= PNG_16_TO_8;
nuclear@0 108 }
nuclear@0 109 #endif
nuclear@0 110
nuclear@0 111 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
nuclear@0 112 void PNGAPI
nuclear@0 113 png_set_strip_alpha(png_structp png_ptr)
nuclear@0 114 {
nuclear@0 115 png_debug(1, "in png_set_strip_alpha\n");
nuclear@0 116 if (png_ptr == NULL) return;
nuclear@0 117 png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
nuclear@0 118 }
nuclear@0 119 #endif
nuclear@0 120
nuclear@0 121 #if defined(PNG_READ_DITHER_SUPPORTED)
nuclear@0 122 /* Dither file to 8 bit. Supply a palette, the current number
nuclear@0 123 * of elements in the palette, the maximum number of elements
nuclear@0 124 * allowed, and a histogram if possible. If the current number
nuclear@0 125 * of colors is greater then the maximum number, the palette will be
nuclear@0 126 * modified to fit in the maximum number. "full_dither" indicates
nuclear@0 127 * whether we need a dithering cube set up for RGB images, or if we
nuclear@0 128 * simply are reducing the number of colors in a paletted image.
nuclear@0 129 */
nuclear@0 130
nuclear@0 131 typedef struct png_dsort_struct
nuclear@0 132 {
nuclear@0 133 struct png_dsort_struct FAR * next;
nuclear@0 134 png_byte left;
nuclear@0 135 png_byte right;
nuclear@0 136 } png_dsort;
nuclear@0 137 typedef png_dsort FAR * png_dsortp;
nuclear@0 138 typedef png_dsort FAR * FAR * png_dsortpp;
nuclear@0 139
nuclear@0 140 void PNGAPI
nuclear@0 141 png_set_dither(png_structp png_ptr, png_colorp palette,
nuclear@0 142 int num_palette, int maximum_colors, png_uint_16p histogram,
nuclear@0 143 int full_dither)
nuclear@0 144 {
nuclear@0 145 png_debug(1, "in png_set_dither\n");
nuclear@0 146 if (png_ptr == NULL) return;
nuclear@0 147 png_ptr->transformations |= PNG_DITHER;
nuclear@0 148
nuclear@0 149 if (!full_dither)
nuclear@0 150 {
nuclear@0 151 int i;
nuclear@0 152
nuclear@0 153 png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,
nuclear@0 154 (png_uint_32)(num_palette * png_sizeof(png_byte)));
nuclear@0 155 for (i = 0; i < num_palette; i++)
nuclear@0 156 png_ptr->dither_index[i] = (png_byte)i;
nuclear@0 157 }
nuclear@0 158
nuclear@0 159 if (num_palette > maximum_colors)
nuclear@0 160 {
nuclear@0 161 if (histogram != NULL)
nuclear@0 162 {
nuclear@0 163 /* This is easy enough, just throw out the least used colors.
nuclear@0 164 Perhaps not the best solution, but good enough. */
nuclear@0 165
nuclear@0 166 int i;
nuclear@0 167
nuclear@0 168 /* initialize an array to sort colors */
nuclear@0 169 png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,
nuclear@0 170 (png_uint_32)(num_palette * png_sizeof(png_byte)));
nuclear@0 171
nuclear@0 172 /* initialize the dither_sort array */
nuclear@0 173 for (i = 0; i < num_palette; i++)
nuclear@0 174 png_ptr->dither_sort[i] = (png_byte)i;
nuclear@0 175
nuclear@0 176 /* Find the least used palette entries by starting a
nuclear@0 177 bubble sort, and running it until we have sorted
nuclear@0 178 out enough colors. Note that we don't care about
nuclear@0 179 sorting all the colors, just finding which are
nuclear@0 180 least used. */
nuclear@0 181
nuclear@0 182 for (i = num_palette - 1; i >= maximum_colors; i--)
nuclear@0 183 {
nuclear@0 184 int done; /* to stop early if the list is pre-sorted */
nuclear@0 185 int j;
nuclear@0 186
nuclear@0 187 done = 1;
nuclear@0 188 for (j = 0; j < i; j++)
nuclear@0 189 {
nuclear@0 190 if (histogram[png_ptr->dither_sort[j]]
nuclear@0 191 < histogram[png_ptr->dither_sort[j + 1]])
nuclear@0 192 {
nuclear@0 193 png_byte t;
nuclear@0 194
nuclear@0 195 t = png_ptr->dither_sort[j];
nuclear@0 196 png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];
nuclear@0 197 png_ptr->dither_sort[j + 1] = t;
nuclear@0 198 done = 0;
nuclear@0 199 }
nuclear@0 200 }
nuclear@0 201 if (done)
nuclear@0 202 break;
nuclear@0 203 }
nuclear@0 204
nuclear@0 205 /* swap the palette around, and set up a table, if necessary */
nuclear@0 206 if (full_dither)
nuclear@0 207 {
nuclear@0 208 int j = num_palette;
nuclear@0 209
nuclear@0 210 /* put all the useful colors within the max, but don't
nuclear@0 211 move the others */
nuclear@0 212 for (i = 0; i < maximum_colors; i++)
nuclear@0 213 {
nuclear@0 214 if ((int)png_ptr->dither_sort[i] >= maximum_colors)
nuclear@0 215 {
nuclear@0 216 do
nuclear@0 217 j--;
nuclear@0 218 while ((int)png_ptr->dither_sort[j] >= maximum_colors);
nuclear@0 219 palette[i] = palette[j];
nuclear@0 220 }
nuclear@0 221 }
nuclear@0 222 }
nuclear@0 223 else
nuclear@0 224 {
nuclear@0 225 int j = num_palette;
nuclear@0 226
nuclear@0 227 /* move all the used colors inside the max limit, and
nuclear@0 228 develop a translation table */
nuclear@0 229 for (i = 0; i < maximum_colors; i++)
nuclear@0 230 {
nuclear@0 231 /* only move the colors we need to */
nuclear@0 232 if ((int)png_ptr->dither_sort[i] >= maximum_colors)
nuclear@0 233 {
nuclear@0 234 png_color tmp_color;
nuclear@0 235
nuclear@0 236 do
nuclear@0 237 j--;
nuclear@0 238 while ((int)png_ptr->dither_sort[j] >= maximum_colors);
nuclear@0 239
nuclear@0 240 tmp_color = palette[j];
nuclear@0 241 palette[j] = palette[i];
nuclear@0 242 palette[i] = tmp_color;
nuclear@0 243 /* indicate where the color went */
nuclear@0 244 png_ptr->dither_index[j] = (png_byte)i;
nuclear@0 245 png_ptr->dither_index[i] = (png_byte)j;
nuclear@0 246 }
nuclear@0 247 }
nuclear@0 248
nuclear@0 249 /* find closest color for those colors we are not using */
nuclear@0 250 for (i = 0; i < num_palette; i++)
nuclear@0 251 {
nuclear@0 252 if ((int)png_ptr->dither_index[i] >= maximum_colors)
nuclear@0 253 {
nuclear@0 254 int min_d, k, min_k, d_index;
nuclear@0 255
nuclear@0 256 /* find the closest color to one we threw out */
nuclear@0 257 d_index = png_ptr->dither_index[i];
nuclear@0 258 min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
nuclear@0 259 for (k = 1, min_k = 0; k < maximum_colors; k++)
nuclear@0 260 {
nuclear@0 261 int d;
nuclear@0 262
nuclear@0 263 d = PNG_COLOR_DIST(palette[d_index], palette[k]);
nuclear@0 264
nuclear@0 265 if (d < min_d)
nuclear@0 266 {
nuclear@0 267 min_d = d;
nuclear@0 268 min_k = k;
nuclear@0 269 }
nuclear@0 270 }
nuclear@0 271 /* point to closest color */
nuclear@0 272 png_ptr->dither_index[i] = (png_byte)min_k;
nuclear@0 273 }
nuclear@0 274 }
nuclear@0 275 }
nuclear@0 276 png_free(png_ptr, png_ptr->dither_sort);
nuclear@0 277 png_ptr->dither_sort = NULL;
nuclear@0 278 }
nuclear@0 279 else
nuclear@0 280 {
nuclear@0 281 /* This is much harder to do simply (and quickly). Perhaps
nuclear@0 282 we need to go through a median cut routine, but those
nuclear@0 283 don't always behave themselves with only a few colors
nuclear@0 284 as input. So we will just find the closest two colors,
nuclear@0 285 and throw out one of them (chosen somewhat randomly).
nuclear@0 286 [We don't understand this at all, so if someone wants to
nuclear@0 287 work on improving it, be our guest - AED, GRP]
nuclear@0 288 */
nuclear@0 289 int i;
nuclear@0 290 int max_d;
nuclear@0 291 int num_new_palette;
nuclear@0 292 png_dsortp t;
nuclear@0 293 png_dsortpp hash;
nuclear@0 294
nuclear@0 295 t = NULL;
nuclear@0 296
nuclear@0 297 /* initialize palette index arrays */
nuclear@0 298 png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
nuclear@0 299 (png_uint_32)(num_palette * png_sizeof(png_byte)));
nuclear@0 300 png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
nuclear@0 301 (png_uint_32)(num_palette * png_sizeof(png_byte)));
nuclear@0 302
nuclear@0 303 /* initialize the sort array */
nuclear@0 304 for (i = 0; i < num_palette; i++)
nuclear@0 305 {
nuclear@0 306 png_ptr->index_to_palette[i] = (png_byte)i;
nuclear@0 307 png_ptr->palette_to_index[i] = (png_byte)i;
nuclear@0 308 }
nuclear@0 309
nuclear@0 310 hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
nuclear@0 311 png_sizeof(png_dsortp)));
nuclear@0 312 for (i = 0; i < 769; i++)
nuclear@0 313 hash[i] = NULL;
nuclear@0 314 /* png_memset(hash, 0, 769 * png_sizeof(png_dsortp)); */
nuclear@0 315
nuclear@0 316 num_new_palette = num_palette;
nuclear@0 317
nuclear@0 318 /* initial wild guess at how far apart the farthest pixel
nuclear@0 319 pair we will be eliminating will be. Larger
nuclear@0 320 numbers mean more areas will be allocated, Smaller
nuclear@0 321 numbers run the risk of not saving enough data, and
nuclear@0 322 having to do this all over again.
nuclear@0 323
nuclear@0 324 I have not done extensive checking on this number.
nuclear@0 325 */
nuclear@0 326 max_d = 96;
nuclear@0 327
nuclear@0 328 while (num_new_palette > maximum_colors)
nuclear@0 329 {
nuclear@0 330 for (i = 0; i < num_new_palette - 1; i++)
nuclear@0 331 {
nuclear@0 332 int j;
nuclear@0 333
nuclear@0 334 for (j = i + 1; j < num_new_palette; j++)
nuclear@0 335 {
nuclear@0 336 int d;
nuclear@0 337
nuclear@0 338 d = PNG_COLOR_DIST(palette[i], palette[j]);
nuclear@0 339
nuclear@0 340 if (d <= max_d)
nuclear@0 341 {
nuclear@0 342
nuclear@0 343 t = (png_dsortp)png_malloc_warn(png_ptr,
nuclear@0 344 (png_uint_32)(png_sizeof(png_dsort)));
nuclear@0 345 if (t == NULL)
nuclear@0 346 break;
nuclear@0 347 t->next = hash[d];
nuclear@0 348 t->left = (png_byte)i;
nuclear@0 349 t->right = (png_byte)j;
nuclear@0 350 hash[d] = t;
nuclear@0 351 }
nuclear@0 352 }
nuclear@0 353 if (t == NULL)
nuclear@0 354 break;
nuclear@0 355 }
nuclear@0 356
nuclear@0 357 if (t != NULL)
nuclear@0 358 for (i = 0; i <= max_d; i++)
nuclear@0 359 {
nuclear@0 360 if (hash[i] != NULL)
nuclear@0 361 {
nuclear@0 362 png_dsortp p;
nuclear@0 363
nuclear@0 364 for (p = hash[i]; p; p = p->next)
nuclear@0 365 {
nuclear@0 366 if ((int)png_ptr->index_to_palette[p->left]
nuclear@0 367 < num_new_palette &&
nuclear@0 368 (int)png_ptr->index_to_palette[p->right]
nuclear@0 369 < num_new_palette)
nuclear@0 370 {
nuclear@0 371 int j, next_j;
nuclear@0 372
nuclear@0 373 if (num_new_palette & 0x01)
nuclear@0 374 {
nuclear@0 375 j = p->left;
nuclear@0 376 next_j = p->right;
nuclear@0 377 }
nuclear@0 378 else
nuclear@0 379 {
nuclear@0 380 j = p->right;
nuclear@0 381 next_j = p->left;
nuclear@0 382 }
nuclear@0 383
nuclear@0 384 num_new_palette--;
nuclear@0 385 palette[png_ptr->index_to_palette[j]]
nuclear@0 386 = palette[num_new_palette];
nuclear@0 387 if (!full_dither)
nuclear@0 388 {
nuclear@0 389 int k;
nuclear@0 390
nuclear@0 391 for (k = 0; k < num_palette; k++)
nuclear@0 392 {
nuclear@0 393 if (png_ptr->dither_index[k] ==
nuclear@0 394 png_ptr->index_to_palette[j])
nuclear@0 395 png_ptr->dither_index[k] =
nuclear@0 396 png_ptr->index_to_palette[next_j];
nuclear@0 397 if ((int)png_ptr->dither_index[k] ==
nuclear@0 398 num_new_palette)
nuclear@0 399 png_ptr->dither_index[k] =
nuclear@0 400 png_ptr->index_to_palette[j];
nuclear@0 401 }
nuclear@0 402 }
nuclear@0 403
nuclear@0 404 png_ptr->index_to_palette[png_ptr->palette_to_index
nuclear@0 405 [num_new_palette]] = png_ptr->index_to_palette[j];
nuclear@0 406 png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
nuclear@0 407 = png_ptr->palette_to_index[num_new_palette];
nuclear@0 408
nuclear@0 409 png_ptr->index_to_palette[j] = (png_byte)num_new_palette;
nuclear@0 410 png_ptr->palette_to_index[num_new_palette] = (png_byte)j;
nuclear@0 411 }
nuclear@0 412 if (num_new_palette <= maximum_colors)
nuclear@0 413 break;
nuclear@0 414 }
nuclear@0 415 if (num_new_palette <= maximum_colors)
nuclear@0 416 break;
nuclear@0 417 }
nuclear@0 418 }
nuclear@0 419
nuclear@0 420 for (i = 0; i < 769; i++)
nuclear@0 421 {
nuclear@0 422 if (hash[i] != NULL)
nuclear@0 423 {
nuclear@0 424 png_dsortp p = hash[i];
nuclear@0 425 while (p)
nuclear@0 426 {
nuclear@0 427 t = p->next;
nuclear@0 428 png_free(png_ptr, p);
nuclear@0 429 p = t;
nuclear@0 430 }
nuclear@0 431 }
nuclear@0 432 hash[i] = 0;
nuclear@0 433 }
nuclear@0 434 max_d += 96;
nuclear@0 435 }
nuclear@0 436 png_free(png_ptr, hash);
nuclear@0 437 png_free(png_ptr, png_ptr->palette_to_index);
nuclear@0 438 png_free(png_ptr, png_ptr->index_to_palette);
nuclear@0 439 png_ptr->palette_to_index = NULL;
nuclear@0 440 png_ptr->index_to_palette = NULL;
nuclear@0 441 }
nuclear@0 442 num_palette = maximum_colors;
nuclear@0 443 }
nuclear@0 444 if (png_ptr->palette == NULL)
nuclear@0 445 {
nuclear@0 446 png_ptr->palette = palette;
nuclear@0 447 }
nuclear@0 448 png_ptr->num_palette = (png_uint_16)num_palette;
nuclear@0 449
nuclear@0 450 if (full_dither)
nuclear@0 451 {
nuclear@0 452 int i;
nuclear@0 453 png_bytep distance;
nuclear@0 454 int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
nuclear@0 455 PNG_DITHER_BLUE_BITS;
nuclear@0 456 int num_red = (1 << PNG_DITHER_RED_BITS);
nuclear@0 457 int num_green = (1 << PNG_DITHER_GREEN_BITS);
nuclear@0 458 int num_blue = (1 << PNG_DITHER_BLUE_BITS);
nuclear@0 459 png_size_t num_entries = ((png_size_t)1 << total_bits);
nuclear@0 460
nuclear@0 461 png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
nuclear@0 462 (png_uint_32)(num_entries * png_sizeof(png_byte)));
nuclear@0 463
nuclear@0 464 png_memset(png_ptr->palette_lookup, 0, num_entries *
nuclear@0 465 png_sizeof(png_byte));
nuclear@0 466
nuclear@0 467 distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
nuclear@0 468 png_sizeof(png_byte)));
nuclear@0 469
nuclear@0 470 png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
nuclear@0 471
nuclear@0 472 for (i = 0; i < num_palette; i++)
nuclear@0 473 {
nuclear@0 474 int ir, ig, ib;
nuclear@0 475 int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
nuclear@0 476 int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
nuclear@0 477 int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
nuclear@0 478
nuclear@0 479 for (ir = 0; ir < num_red; ir++)
nuclear@0 480 {
nuclear@0 481 /* int dr = abs(ir - r); */
nuclear@0 482 int dr = ((ir > r) ? ir - r : r - ir);
nuclear@0 483 int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));
nuclear@0 484
nuclear@0 485 for (ig = 0; ig < num_green; ig++)
nuclear@0 486 {
nuclear@0 487 /* int dg = abs(ig - g); */
nuclear@0 488 int dg = ((ig > g) ? ig - g : g - ig);
nuclear@0 489 int dt = dr + dg;
nuclear@0 490 int dm = ((dr > dg) ? dr : dg);
nuclear@0 491 int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);
nuclear@0 492
nuclear@0 493 for (ib = 0; ib < num_blue; ib++)
nuclear@0 494 {
nuclear@0 495 int d_index = index_g | ib;
nuclear@0 496 /* int db = abs(ib - b); */
nuclear@0 497 int db = ((ib > b) ? ib - b : b - ib);
nuclear@0 498 int dmax = ((dm > db) ? dm : db);
nuclear@0 499 int d = dmax + dt + db;
nuclear@0 500
nuclear@0 501 if (d < (int)distance[d_index])
nuclear@0 502 {
nuclear@0 503 distance[d_index] = (png_byte)d;
nuclear@0 504 png_ptr->palette_lookup[d_index] = (png_byte)i;
nuclear@0 505 }
nuclear@0 506 }
nuclear@0 507 }
nuclear@0 508 }
nuclear@0 509 }
nuclear@0 510
nuclear@0 511 png_free(png_ptr, distance);
nuclear@0 512 }
nuclear@0 513 }
nuclear@0 514 #endif
nuclear@0 515
nuclear@0 516 #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
nuclear@0 517 /* Transform the image from the file_gamma to the screen_gamma. We
nuclear@0 518 * only do transformations on images where the file_gamma and screen_gamma
nuclear@0 519 * are not close reciprocals, otherwise it slows things down slightly, and
nuclear@0 520 * also needlessly introduces small errors.
nuclear@0 521 *
nuclear@0 522 * We will turn off gamma transformation later if no semitransparent entries
nuclear@0 523 * are present in the tRNS array for palette images. We can't do it here
nuclear@0 524 * because we don't necessarily have the tRNS chunk yet.
nuclear@0 525 */
nuclear@0 526 void PNGAPI
nuclear@0 527 png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
nuclear@0 528 {
nuclear@0 529 png_debug(1, "in png_set_gamma\n");
nuclear@0 530 if (png_ptr == NULL) return;
nuclear@0 531 if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
nuclear@0 532 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
nuclear@0 533 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
nuclear@0 534 png_ptr->transformations |= PNG_GAMMA;
nuclear@0 535 png_ptr->gamma = (float)file_gamma;
nuclear@0 536 png_ptr->screen_gamma = (float)scrn_gamma;
nuclear@0 537 }
nuclear@0 538 #endif
nuclear@0 539
nuclear@0 540 #if defined(PNG_READ_EXPAND_SUPPORTED)
nuclear@0 541 /* Expand paletted images to RGB, expand grayscale images of
nuclear@0 542 * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
nuclear@0 543 * to alpha channels.
nuclear@0 544 */
nuclear@0 545 void PNGAPI
nuclear@0 546 png_set_expand(png_structp png_ptr)
nuclear@0 547 {
nuclear@0 548 png_debug(1, "in png_set_expand\n");
nuclear@0 549 if (png_ptr == NULL) return;
nuclear@0 550 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
nuclear@0 551 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
nuclear@0 552 }
nuclear@0 553
nuclear@0 554 /* GRR 19990627: the following three functions currently are identical
nuclear@0 555 * to png_set_expand(). However, it is entirely reasonable that someone
nuclear@0 556 * might wish to expand an indexed image to RGB but *not* expand a single,
nuclear@0 557 * fully transparent palette entry to a full alpha channel--perhaps instead
nuclear@0 558 * convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace
nuclear@0 559 * the transparent color with a particular RGB value, or drop tRNS entirely.
nuclear@0 560 * IOW, a future version of the library may make the transformations flag
nuclear@0 561 * a bit more fine-grained, with separate bits for each of these three
nuclear@0 562 * functions.
nuclear@0 563 *
nuclear@0 564 * More to the point, these functions make it obvious what libpng will be
nuclear@0 565 * doing, whereas "expand" can (and does) mean any number of things.
nuclear@0 566 *
nuclear@0 567 * GRP 20060307: In libpng-1.4.0, png_set_gray_1_2_4_to_8() was modified
nuclear@0 568 * to expand only the sample depth but not to expand the tRNS to alpha.
nuclear@0 569 */
nuclear@0 570
nuclear@0 571 /* Expand paletted images to RGB. */
nuclear@0 572 void PNGAPI
nuclear@0 573 png_set_palette_to_rgb(png_structp png_ptr)
nuclear@0 574 {
nuclear@0 575 png_debug(1, "in png_set_palette_to_rgb\n");
nuclear@0 576 if (png_ptr == NULL) return;
nuclear@0 577 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
nuclear@0 578 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
nuclear@0 579 }
nuclear@0 580
nuclear@0 581 #if !defined(PNG_1_0_X)
nuclear@0 582 /* Expand grayscale images of less than 8-bit depth to 8 bits. */
nuclear@0 583 void PNGAPI
nuclear@0 584 png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
nuclear@0 585 {
nuclear@0 586 png_debug(1, "in png_set_expand_gray_1_2_4_to_8\n");
nuclear@0 587 if (png_ptr == NULL) return;
nuclear@0 588 png_ptr->transformations |= PNG_EXPAND;
nuclear@0 589 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
nuclear@0 590 }
nuclear@0 591 #endif
nuclear@0 592
nuclear@0 593 #if defined(PNG_1_0_X) || defined(PNG_1_2_X)
nuclear@0 594 /* Expand grayscale images of less than 8-bit depth to 8 bits. */
nuclear@0 595 /* Deprecated as of libpng-1.2.9 */
nuclear@0 596 void PNGAPI
nuclear@0 597 png_set_gray_1_2_4_to_8(png_structp png_ptr)
nuclear@0 598 {
nuclear@0 599 png_debug(1, "in png_set_gray_1_2_4_to_8\n");
nuclear@0 600 if (png_ptr == NULL) return;
nuclear@0 601 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
nuclear@0 602 }
nuclear@0 603 #endif
nuclear@0 604
nuclear@0 605
nuclear@0 606 /* Expand tRNS chunks to alpha channels. */
nuclear@0 607 void PNGAPI
nuclear@0 608 png_set_tRNS_to_alpha(png_structp png_ptr)
nuclear@0 609 {
nuclear@0 610 png_debug(1, "in png_set_tRNS_to_alpha\n");
nuclear@0 611 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
nuclear@0 612 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
nuclear@0 613 }
nuclear@0 614 #endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
nuclear@0 615
nuclear@0 616 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
nuclear@0 617 void PNGAPI
nuclear@0 618 png_set_gray_to_rgb(png_structp png_ptr)
nuclear@0 619 {
nuclear@0 620 png_debug(1, "in png_set_gray_to_rgb\n");
nuclear@0 621 png_ptr->transformations |= PNG_GRAY_TO_RGB;
nuclear@0 622 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
nuclear@0 623 }
nuclear@0 624 #endif
nuclear@0 625
nuclear@0 626 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
nuclear@0 627 #if defined(PNG_FLOATING_POINT_SUPPORTED)
nuclear@0 628 /* Convert a RGB image to a grayscale of the same width. This allows us,
nuclear@0 629 * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
nuclear@0 630 */
nuclear@0 631
nuclear@0 632 void PNGAPI
nuclear@0 633 png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
nuclear@0 634 double green)
nuclear@0 635 {
nuclear@0 636 int red_fixed = (int)((float)red*100000.0 + 0.5);
nuclear@0 637 int green_fixed = (int)((float)green*100000.0 + 0.5);
nuclear@0 638 if (png_ptr == NULL) return;
nuclear@0 639 png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);
nuclear@0 640 }
nuclear@0 641 #endif
nuclear@0 642
nuclear@0 643 void PNGAPI
nuclear@0 644 png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
nuclear@0 645 png_fixed_point red, png_fixed_point green)
nuclear@0 646 {
nuclear@0 647 png_debug(1, "in png_set_rgb_to_gray\n");
nuclear@0 648 if (png_ptr == NULL) return;
nuclear@0 649 switch(error_action)
nuclear@0 650 {
nuclear@0 651 case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
nuclear@0 652 break;
nuclear@0 653 case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
nuclear@0 654 break;
nuclear@0 655 case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
nuclear@0 656 }
nuclear@0 657 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 658 #if defined(PNG_READ_EXPAND_SUPPORTED)
nuclear@0 659 png_ptr->transformations |= PNG_EXPAND;
nuclear@0 660 #else
nuclear@0 661 {
nuclear@0 662 png_warning(png_ptr,
nuclear@0 663 "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");
nuclear@0 664 png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
nuclear@0 665 }
nuclear@0 666 #endif
nuclear@0 667 {
nuclear@0 668 png_uint_16 red_int, green_int;
nuclear@0 669 if (red < 0 || green < 0)
nuclear@0 670 {
nuclear@0 671 red_int = 6968; /* .212671 * 32768 + .5 */
nuclear@0 672 green_int = 23434; /* .715160 * 32768 + .5 */
nuclear@0 673 }
nuclear@0 674 else if (red + green < 100000L)
nuclear@0 675 {
nuclear@0 676 red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);
nuclear@0 677 green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);
nuclear@0 678 }
nuclear@0 679 else
nuclear@0 680 {
nuclear@0 681 png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");
nuclear@0 682 red_int = 6968;
nuclear@0 683 green_int = 23434;
nuclear@0 684 }
nuclear@0 685 png_ptr->rgb_to_gray_red_coeff = red_int;
nuclear@0 686 png_ptr->rgb_to_gray_green_coeff = green_int;
nuclear@0 687 png_ptr->rgb_to_gray_blue_coeff =
nuclear@0 688 (png_uint_16)(32768 - red_int - green_int);
nuclear@0 689 }
nuclear@0 690 }
nuclear@0 691 #endif
nuclear@0 692
nuclear@0 693 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
nuclear@0 694 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
nuclear@0 695 defined(PNG_LEGACY_SUPPORTED)
nuclear@0 696 void PNGAPI
nuclear@0 697 png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
nuclear@0 698 read_user_transform_fn)
nuclear@0 699 {
nuclear@0 700 png_debug(1, "in png_set_read_user_transform_fn\n");
nuclear@0 701 if (png_ptr == NULL) return;
nuclear@0 702 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
nuclear@0 703 png_ptr->transformations |= PNG_USER_TRANSFORM;
nuclear@0 704 png_ptr->read_user_transform_fn = read_user_transform_fn;
nuclear@0 705 #endif
nuclear@0 706 #ifdef PNG_LEGACY_SUPPORTED
nuclear@0 707 if (read_user_transform_fn)
nuclear@0 708 png_warning(png_ptr,
nuclear@0 709 "This version of libpng does not support user transforms");
nuclear@0 710 #endif
nuclear@0 711 }
nuclear@0 712 #endif
nuclear@0 713
nuclear@0 714 /* Initialize everything needed for the read. This includes modifying
nuclear@0 715 * the palette.
nuclear@0 716 */
nuclear@0 717 void /* PRIVATE */
nuclear@0 718 png_init_read_transformations(png_structp png_ptr)
nuclear@0 719 {
nuclear@0 720 png_debug(1, "in png_init_read_transformations\n");
nuclear@0 721 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 722 if (png_ptr != NULL)
nuclear@0 723 #endif
nuclear@0 724 {
nuclear@0 725 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \
nuclear@0 726 || defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 727 int color_type = png_ptr->color_type;
nuclear@0 728 #endif
nuclear@0 729
nuclear@0 730 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 731
nuclear@0 732 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
nuclear@0 733 /* Detect gray background and attempt to enable optimization
nuclear@0 734 * for gray --> RGB case */
nuclear@0 735 /* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
nuclear@0 736 * RGB_ALPHA (in which case need_expand is superfluous anyway), the
nuclear@0 737 * background color might actually be gray yet not be flagged as such.
nuclear@0 738 * This is not a problem for the current code, which uses
nuclear@0 739 * PNG_BACKGROUND_IS_GRAY only to decide when to do the
nuclear@0 740 * png_do_gray_to_rgb() transformation.
nuclear@0 741 */
nuclear@0 742 if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
nuclear@0 743 !(color_type & PNG_COLOR_MASK_COLOR))
nuclear@0 744 {
nuclear@0 745 png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
nuclear@0 746 } else if ((png_ptr->transformations & PNG_BACKGROUND) &&
nuclear@0 747 !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
nuclear@0 748 (png_ptr->transformations & PNG_GRAY_TO_RGB) &&
nuclear@0 749 png_ptr->background.red == png_ptr->background.green &&
nuclear@0 750 png_ptr->background.red == png_ptr->background.blue)
nuclear@0 751 {
nuclear@0 752 png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
nuclear@0 753 png_ptr->background.gray = png_ptr->background.red;
nuclear@0 754 }
nuclear@0 755 #endif
nuclear@0 756
nuclear@0 757 if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&
nuclear@0 758 (png_ptr->transformations & PNG_EXPAND))
nuclear@0 759 {
nuclear@0 760 if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */
nuclear@0 761 {
nuclear@0 762 /* expand background and tRNS chunks */
nuclear@0 763 switch (png_ptr->bit_depth)
nuclear@0 764 {
nuclear@0 765 case 1:
nuclear@0 766 png_ptr->background.gray *= (png_uint_16)0xff;
nuclear@0 767 png_ptr->background.red = png_ptr->background.green
nuclear@0 768 = png_ptr->background.blue = png_ptr->background.gray;
nuclear@0 769 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
nuclear@0 770 {
nuclear@0 771 png_ptr->trans_values.gray *= (png_uint_16)0xff;
nuclear@0 772 png_ptr->trans_values.red = png_ptr->trans_values.green
nuclear@0 773 = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
nuclear@0 774 }
nuclear@0 775 break;
nuclear@0 776 case 2:
nuclear@0 777 png_ptr->background.gray *= (png_uint_16)0x55;
nuclear@0 778 png_ptr->background.red = png_ptr->background.green
nuclear@0 779 = png_ptr->background.blue = png_ptr->background.gray;
nuclear@0 780 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
nuclear@0 781 {
nuclear@0 782 png_ptr->trans_values.gray *= (png_uint_16)0x55;
nuclear@0 783 png_ptr->trans_values.red = png_ptr->trans_values.green
nuclear@0 784 = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
nuclear@0 785 }
nuclear@0 786 break;
nuclear@0 787 case 4:
nuclear@0 788 png_ptr->background.gray *= (png_uint_16)0x11;
nuclear@0 789 png_ptr->background.red = png_ptr->background.green
nuclear@0 790 = png_ptr->background.blue = png_ptr->background.gray;
nuclear@0 791 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
nuclear@0 792 {
nuclear@0 793 png_ptr->trans_values.gray *= (png_uint_16)0x11;
nuclear@0 794 png_ptr->trans_values.red = png_ptr->trans_values.green
nuclear@0 795 = png_ptr->trans_values.blue = png_ptr->trans_values.gray;
nuclear@0 796 }
nuclear@0 797 break;
nuclear@0 798 case 8:
nuclear@0 799 case 16:
nuclear@0 800 png_ptr->background.red = png_ptr->background.green
nuclear@0 801 = png_ptr->background.blue = png_ptr->background.gray;
nuclear@0 802 break;
nuclear@0 803 }
nuclear@0 804 }
nuclear@0 805 else if (color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 806 {
nuclear@0 807 png_ptr->background.red =
nuclear@0 808 png_ptr->palette[png_ptr->background.index].red;
nuclear@0 809 png_ptr->background.green =
nuclear@0 810 png_ptr->palette[png_ptr->background.index].green;
nuclear@0 811 png_ptr->background.blue =
nuclear@0 812 png_ptr->palette[png_ptr->background.index].blue;
nuclear@0 813
nuclear@0 814 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
nuclear@0 815 if (png_ptr->transformations & PNG_INVERT_ALPHA)
nuclear@0 816 {
nuclear@0 817 #if defined(PNG_READ_EXPAND_SUPPORTED)
nuclear@0 818 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
nuclear@0 819 #endif
nuclear@0 820 {
nuclear@0 821 /* invert the alpha channel (in tRNS) unless the pixels are
nuclear@0 822 going to be expanded, in which case leave it for later */
nuclear@0 823 int i, istop;
nuclear@0 824 istop=(int)png_ptr->num_trans;
nuclear@0 825 for (i=0; i<istop; i++)
nuclear@0 826 png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);
nuclear@0 827 }
nuclear@0 828 }
nuclear@0 829 #endif
nuclear@0 830
nuclear@0 831 }
nuclear@0 832 }
nuclear@0 833 #endif
nuclear@0 834
nuclear@0 835 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 836 png_ptr->background_1 = png_ptr->background;
nuclear@0 837 #endif
nuclear@0 838 #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
nuclear@0 839
nuclear@0 840 if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)
nuclear@0 841 && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)
nuclear@0 842 < PNG_GAMMA_THRESHOLD))
nuclear@0 843 {
nuclear@0 844 int i, k;
nuclear@0 845 k=0;
nuclear@0 846 for (i=0; i<png_ptr->num_trans; i++)
nuclear@0 847 {
nuclear@0 848 if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
nuclear@0 849 k=1; /* partial transparency is present */
nuclear@0 850 }
nuclear@0 851 if (k == 0)
nuclear@0 852 png_ptr->transformations &= ~PNG_GAMMA;
nuclear@0 853 }
nuclear@0 854
nuclear@0 855 if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&
nuclear@0 856 png_ptr->gamma != 0.0)
nuclear@0 857 {
nuclear@0 858 png_build_gamma_table(png_ptr);
nuclear@0 859 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 860 if (png_ptr->transformations & PNG_BACKGROUND)
nuclear@0 861 {
nuclear@0 862 if (color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 863 {
nuclear@0 864 /* could skip if no transparency and
nuclear@0 865 */
nuclear@0 866 png_color back, back_1;
nuclear@0 867 png_colorp palette = png_ptr->palette;
nuclear@0 868 int num_palette = png_ptr->num_palette;
nuclear@0 869 int i;
nuclear@0 870 if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
nuclear@0 871 {
nuclear@0 872 back.red = png_ptr->gamma_table[png_ptr->background.red];
nuclear@0 873 back.green = png_ptr->gamma_table[png_ptr->background.green];
nuclear@0 874 back.blue = png_ptr->gamma_table[png_ptr->background.blue];
nuclear@0 875
nuclear@0 876 back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
nuclear@0 877 back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
nuclear@0 878 back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
nuclear@0 879 }
nuclear@0 880 else
nuclear@0 881 {
nuclear@0 882 double g, gs;
nuclear@0 883
nuclear@0 884 switch (png_ptr->background_gamma_type)
nuclear@0 885 {
nuclear@0 886 case PNG_BACKGROUND_GAMMA_SCREEN:
nuclear@0 887 g = (png_ptr->screen_gamma);
nuclear@0 888 gs = 1.0;
nuclear@0 889 break;
nuclear@0 890 case PNG_BACKGROUND_GAMMA_FILE:
nuclear@0 891 g = 1.0 / (png_ptr->gamma);
nuclear@0 892 gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
nuclear@0 893 break;
nuclear@0 894 case PNG_BACKGROUND_GAMMA_UNIQUE:
nuclear@0 895 g = 1.0 / (png_ptr->background_gamma);
nuclear@0 896 gs = 1.0 / (png_ptr->background_gamma *
nuclear@0 897 png_ptr->screen_gamma);
nuclear@0 898 break;
nuclear@0 899 default:
nuclear@0 900 g = 1.0; /* back_1 */
nuclear@0 901 gs = 1.0; /* back */
nuclear@0 902 }
nuclear@0 903
nuclear@0 904 if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)
nuclear@0 905 {
nuclear@0 906 back.red = (png_byte)png_ptr->background.red;
nuclear@0 907 back.green = (png_byte)png_ptr->background.green;
nuclear@0 908 back.blue = (png_byte)png_ptr->background.blue;
nuclear@0 909 }
nuclear@0 910 else
nuclear@0 911 {
nuclear@0 912 back.red = (png_byte)(pow(
nuclear@0 913 (double)png_ptr->background.red/255, gs) * 255.0 + .5);
nuclear@0 914 back.green = (png_byte)(pow(
nuclear@0 915 (double)png_ptr->background.green/255, gs) * 255.0 + .5);
nuclear@0 916 back.blue = (png_byte)(pow(
nuclear@0 917 (double)png_ptr->background.blue/255, gs) * 255.0 + .5);
nuclear@0 918 }
nuclear@0 919
nuclear@0 920 back_1.red = (png_byte)(pow(
nuclear@0 921 (double)png_ptr->background.red/255, g) * 255.0 + .5);
nuclear@0 922 back_1.green = (png_byte)(pow(
nuclear@0 923 (double)png_ptr->background.green/255, g) * 255.0 + .5);
nuclear@0 924 back_1.blue = (png_byte)(pow(
nuclear@0 925 (double)png_ptr->background.blue/255, g) * 255.0 + .5);
nuclear@0 926 }
nuclear@0 927 for (i = 0; i < num_palette; i++)
nuclear@0 928 {
nuclear@0 929 if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)
nuclear@0 930 {
nuclear@0 931 if (png_ptr->trans[i] == 0)
nuclear@0 932 {
nuclear@0 933 palette[i] = back;
nuclear@0 934 }
nuclear@0 935 else /* if (png_ptr->trans[i] != 0xff) */
nuclear@0 936 {
nuclear@0 937 png_byte v, w;
nuclear@0 938
nuclear@0 939 v = png_ptr->gamma_to_1[palette[i].red];
nuclear@0 940 png_composite(w, v, png_ptr->trans[i], back_1.red);
nuclear@0 941 palette[i].red = png_ptr->gamma_from_1[w];
nuclear@0 942
nuclear@0 943 v = png_ptr->gamma_to_1[palette[i].green];
nuclear@0 944 png_composite(w, v, png_ptr->trans[i], back_1.green);
nuclear@0 945 palette[i].green = png_ptr->gamma_from_1[w];
nuclear@0 946
nuclear@0 947 v = png_ptr->gamma_to_1[palette[i].blue];
nuclear@0 948 png_composite(w, v, png_ptr->trans[i], back_1.blue);
nuclear@0 949 palette[i].blue = png_ptr->gamma_from_1[w];
nuclear@0 950 }
nuclear@0 951 }
nuclear@0 952 else
nuclear@0 953 {
nuclear@0 954 palette[i].red = png_ptr->gamma_table[palette[i].red];
nuclear@0 955 palette[i].green = png_ptr->gamma_table[palette[i].green];
nuclear@0 956 palette[i].blue = png_ptr->gamma_table[palette[i].blue];
nuclear@0 957 }
nuclear@0 958 }
nuclear@0 959 /* Prevent the transformations being done again, and make sure
nuclear@0 960 * that the now spurious alpha channel is stripped - the code
nuclear@0 961 * has just reduced background composition and gamma correction
nuclear@0 962 * to a simple alpha channel strip.
nuclear@0 963 */
nuclear@0 964 png_ptr->transformations &= ~PNG_BACKGROUND;
nuclear@0 965 png_ptr->transformations &= ~PNG_GAMMA;
nuclear@0 966 png_ptr->transformations |= PNG_STRIP_ALPHA;
nuclear@0 967 }
nuclear@0 968 /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
nuclear@0 969 else
nuclear@0 970 /* color_type != PNG_COLOR_TYPE_PALETTE */
nuclear@0 971 {
nuclear@0 972 double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);
nuclear@0 973 double g = 1.0;
nuclear@0 974 double gs = 1.0;
nuclear@0 975
nuclear@0 976 switch (png_ptr->background_gamma_type)
nuclear@0 977 {
nuclear@0 978 case PNG_BACKGROUND_GAMMA_SCREEN:
nuclear@0 979 g = (png_ptr->screen_gamma);
nuclear@0 980 gs = 1.0;
nuclear@0 981 break;
nuclear@0 982 case PNG_BACKGROUND_GAMMA_FILE:
nuclear@0 983 g = 1.0 / (png_ptr->gamma);
nuclear@0 984 gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
nuclear@0 985 break;
nuclear@0 986 case PNG_BACKGROUND_GAMMA_UNIQUE:
nuclear@0 987 g = 1.0 / (png_ptr->background_gamma);
nuclear@0 988 gs = 1.0 / (png_ptr->background_gamma *
nuclear@0 989 png_ptr->screen_gamma);
nuclear@0 990 break;
nuclear@0 991 }
nuclear@0 992
nuclear@0 993 png_ptr->background_1.gray = (png_uint_16)(pow(
nuclear@0 994 (double)png_ptr->background.gray / m, g) * m + .5);
nuclear@0 995 png_ptr->background.gray = (png_uint_16)(pow(
nuclear@0 996 (double)png_ptr->background.gray / m, gs) * m + .5);
nuclear@0 997
nuclear@0 998 if ((png_ptr->background.red != png_ptr->background.green) ||
nuclear@0 999 (png_ptr->background.red != png_ptr->background.blue) ||
nuclear@0 1000 (png_ptr->background.red != png_ptr->background.gray))
nuclear@0 1001 {
nuclear@0 1002 /* RGB or RGBA with color background */
nuclear@0 1003 png_ptr->background_1.red = (png_uint_16)(pow(
nuclear@0 1004 (double)png_ptr->background.red / m, g) * m + .5);
nuclear@0 1005 png_ptr->background_1.green = (png_uint_16)(pow(
nuclear@0 1006 (double)png_ptr->background.green / m, g) * m + .5);
nuclear@0 1007 png_ptr->background_1.blue = (png_uint_16)(pow(
nuclear@0 1008 (double)png_ptr->background.blue / m, g) * m + .5);
nuclear@0 1009 png_ptr->background.red = (png_uint_16)(pow(
nuclear@0 1010 (double)png_ptr->background.red / m, gs) * m + .5);
nuclear@0 1011 png_ptr->background.green = (png_uint_16)(pow(
nuclear@0 1012 (double)png_ptr->background.green / m, gs) * m + .5);
nuclear@0 1013 png_ptr->background.blue = (png_uint_16)(pow(
nuclear@0 1014 (double)png_ptr->background.blue / m, gs) * m + .5);
nuclear@0 1015 }
nuclear@0 1016 else
nuclear@0 1017 {
nuclear@0 1018 /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
nuclear@0 1019 png_ptr->background_1.red = png_ptr->background_1.green
nuclear@0 1020 = png_ptr->background_1.blue = png_ptr->background_1.gray;
nuclear@0 1021 png_ptr->background.red = png_ptr->background.green
nuclear@0 1022 = png_ptr->background.blue = png_ptr->background.gray;
nuclear@0 1023 }
nuclear@0 1024 }
nuclear@0 1025 }
nuclear@0 1026 else
nuclear@0 1027 /* transformation does not include PNG_BACKGROUND */
nuclear@0 1028 #endif /* PNG_READ_BACKGROUND_SUPPORTED */
nuclear@0 1029 if (color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 1030 {
nuclear@0 1031 png_colorp palette = png_ptr->palette;
nuclear@0 1032 int num_palette = png_ptr->num_palette;
nuclear@0 1033 int i;
nuclear@0 1034
nuclear@0 1035 for (i = 0; i < num_palette; i++)
nuclear@0 1036 {
nuclear@0 1037 palette[i].red = png_ptr->gamma_table[palette[i].red];
nuclear@0 1038 palette[i].green = png_ptr->gamma_table[palette[i].green];
nuclear@0 1039 palette[i].blue = png_ptr->gamma_table[palette[i].blue];
nuclear@0 1040 }
nuclear@0 1041
nuclear@0 1042 /* Done the gamma correction. */
nuclear@0 1043 png_ptr->transformations &= ~PNG_GAMMA;
nuclear@0 1044 }
nuclear@0 1045 }
nuclear@0 1046 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 1047 else
nuclear@0 1048 #endif
nuclear@0 1049 #endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
nuclear@0 1050 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 1051 /* No GAMMA transformation */
nuclear@0 1052 if ((png_ptr->transformations & PNG_BACKGROUND) &&
nuclear@0 1053 (color_type == PNG_COLOR_TYPE_PALETTE))
nuclear@0 1054 {
nuclear@0 1055 int i;
nuclear@0 1056 int istop = (int)png_ptr->num_trans;
nuclear@0 1057 png_color back;
nuclear@0 1058 png_colorp palette = png_ptr->palette;
nuclear@0 1059
nuclear@0 1060 back.red = (png_byte)png_ptr->background.red;
nuclear@0 1061 back.green = (png_byte)png_ptr->background.green;
nuclear@0 1062 back.blue = (png_byte)png_ptr->background.blue;
nuclear@0 1063
nuclear@0 1064 for (i = 0; i < istop; i++)
nuclear@0 1065 {
nuclear@0 1066 if (png_ptr->trans[i] == 0)
nuclear@0 1067 {
nuclear@0 1068 palette[i] = back;
nuclear@0 1069 }
nuclear@0 1070 else if (png_ptr->trans[i] != 0xff)
nuclear@0 1071 {
nuclear@0 1072 /* The png_composite() macro is defined in png.h */
nuclear@0 1073 png_composite(palette[i].red, palette[i].red,
nuclear@0 1074 png_ptr->trans[i], back.red);
nuclear@0 1075 png_composite(palette[i].green, palette[i].green,
nuclear@0 1076 png_ptr->trans[i], back.green);
nuclear@0 1077 png_composite(palette[i].blue, palette[i].blue,
nuclear@0 1078 png_ptr->trans[i], back.blue);
nuclear@0 1079 }
nuclear@0 1080 }
nuclear@0 1081
nuclear@0 1082 /* Handled alpha, still need to strip the channel. */
nuclear@0 1083 png_ptr->transformations &= ~PNG_BACKGROUND;
nuclear@0 1084 png_ptr->transformations |= PNG_STRIP_ALPHA;
nuclear@0 1085 }
nuclear@0 1086 #endif /* PNG_READ_BACKGROUND_SUPPORTED */
nuclear@0 1087
nuclear@0 1088 #if defined(PNG_READ_SHIFT_SUPPORTED)
nuclear@0 1089 if ((png_ptr->transformations & PNG_SHIFT) &&
nuclear@0 1090 (color_type == PNG_COLOR_TYPE_PALETTE))
nuclear@0 1091 {
nuclear@0 1092 png_uint_16 i;
nuclear@0 1093 png_uint_16 istop = png_ptr->num_palette;
nuclear@0 1094 int sr = 8 - png_ptr->sig_bit.red;
nuclear@0 1095 int sg = 8 - png_ptr->sig_bit.green;
nuclear@0 1096 int sb = 8 - png_ptr->sig_bit.blue;
nuclear@0 1097
nuclear@0 1098 if (sr < 0 || sr > 8)
nuclear@0 1099 sr = 0;
nuclear@0 1100 if (sg < 0 || sg > 8)
nuclear@0 1101 sg = 0;
nuclear@0 1102 if (sb < 0 || sb > 8)
nuclear@0 1103 sb = 0;
nuclear@0 1104 for (i = 0; i < istop; i++)
nuclear@0 1105 {
nuclear@0 1106 png_ptr->palette[i].red >>= sr;
nuclear@0 1107 png_ptr->palette[i].green >>= sg;
nuclear@0 1108 png_ptr->palette[i].blue >>= sb;
nuclear@0 1109 }
nuclear@0 1110 }
nuclear@0 1111 #endif /* PNG_READ_SHIFT_SUPPORTED */
nuclear@0 1112 }
nuclear@0 1113 #if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \
nuclear@0 1114 && !defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 1115 if (png_ptr)
nuclear@0 1116 return;
nuclear@0 1117 #endif
nuclear@0 1118 }
nuclear@0 1119
nuclear@0 1120 /* Modify the info structure to reflect the transformations. The
nuclear@0 1121 * info should be updated so a PNG file could be written with it,
nuclear@0 1122 * assuming the transformations result in valid PNG data.
nuclear@0 1123 */
nuclear@0 1124 void /* PRIVATE */
nuclear@0 1125 png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
nuclear@0 1126 {
nuclear@0 1127 png_debug(1, "in png_read_transform_info\n");
nuclear@0 1128 #if defined(PNG_READ_EXPAND_SUPPORTED)
nuclear@0 1129 if (png_ptr->transformations & PNG_EXPAND)
nuclear@0 1130 {
nuclear@0 1131 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 1132 {
nuclear@0 1133 if (png_ptr->num_trans &&
nuclear@0 1134 (png_ptr->transformations & PNG_EXPAND_tRNS))
nuclear@0 1135 info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
nuclear@0 1136 else
nuclear@0 1137 info_ptr->color_type = PNG_COLOR_TYPE_RGB;
nuclear@0 1138 info_ptr->bit_depth = 8;
nuclear@0 1139 info_ptr->num_trans = 0;
nuclear@0 1140 }
nuclear@0 1141 else
nuclear@0 1142 {
nuclear@0 1143 if (png_ptr->num_trans)
nuclear@0 1144 {
nuclear@0 1145 if (png_ptr->transformations & PNG_EXPAND_tRNS)
nuclear@0 1146 info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
nuclear@0 1147 #if 0 /* Removed from libpng-1.2.27 */
nuclear@0 1148 else
nuclear@0 1149 info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
nuclear@0 1150 #endif
nuclear@0 1151 }
nuclear@0 1152 if (info_ptr->bit_depth < 8)
nuclear@0 1153 info_ptr->bit_depth = 8;
nuclear@0 1154 info_ptr->num_trans = 0;
nuclear@0 1155 }
nuclear@0 1156 }
nuclear@0 1157 #endif
nuclear@0 1158
nuclear@0 1159 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 1160 if (png_ptr->transformations & PNG_BACKGROUND)
nuclear@0 1161 {
nuclear@0 1162 info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
nuclear@0 1163 info_ptr->num_trans = 0;
nuclear@0 1164 info_ptr->background = png_ptr->background;
nuclear@0 1165 }
nuclear@0 1166 #endif
nuclear@0 1167
nuclear@0 1168 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 1169 if (png_ptr->transformations & PNG_GAMMA)
nuclear@0 1170 {
nuclear@0 1171 #ifdef PNG_FLOATING_POINT_SUPPORTED
nuclear@0 1172 info_ptr->gamma = png_ptr->gamma;
nuclear@0 1173 #endif
nuclear@0 1174 #ifdef PNG_FIXED_POINT_SUPPORTED
nuclear@0 1175 info_ptr->int_gamma = png_ptr->int_gamma;
nuclear@0 1176 #endif
nuclear@0 1177 }
nuclear@0 1178 #endif
nuclear@0 1179
nuclear@0 1180 #if defined(PNG_READ_16_TO_8_SUPPORTED)
nuclear@0 1181 if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
nuclear@0 1182 info_ptr->bit_depth = 8;
nuclear@0 1183 #endif
nuclear@0 1184
nuclear@0 1185 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
nuclear@0 1186 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
nuclear@0 1187 info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
nuclear@0 1188 #endif
nuclear@0 1189
nuclear@0 1190 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
nuclear@0 1191 if (png_ptr->transformations & PNG_RGB_TO_GRAY)
nuclear@0 1192 info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
nuclear@0 1193 #endif
nuclear@0 1194
nuclear@0 1195 #if defined(PNG_READ_DITHER_SUPPORTED)
nuclear@0 1196 if (png_ptr->transformations & PNG_DITHER)
nuclear@0 1197 {
nuclear@0 1198 if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
nuclear@0 1199 (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
nuclear@0 1200 png_ptr->palette_lookup && info_ptr->bit_depth == 8)
nuclear@0 1201 {
nuclear@0 1202 info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
nuclear@0 1203 }
nuclear@0 1204 }
nuclear@0 1205 #endif
nuclear@0 1206
nuclear@0 1207 #if defined(PNG_READ_PACK_SUPPORTED)
nuclear@0 1208 if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
nuclear@0 1209 info_ptr->bit_depth = 8;
nuclear@0 1210 #endif
nuclear@0 1211
nuclear@0 1212 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 1213 info_ptr->channels = 1;
nuclear@0 1214 else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
nuclear@0 1215 info_ptr->channels = 3;
nuclear@0 1216 else
nuclear@0 1217 info_ptr->channels = 1;
nuclear@0 1218
nuclear@0 1219 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
nuclear@0 1220 if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
nuclear@0 1221 info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
nuclear@0 1222 #endif
nuclear@0 1223
nuclear@0 1224 if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
nuclear@0 1225 info_ptr->channels++;
nuclear@0 1226
nuclear@0 1227 #if defined(PNG_READ_FILLER_SUPPORTED)
nuclear@0 1228 /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */
nuclear@0 1229 if ((png_ptr->transformations & PNG_FILLER) &&
nuclear@0 1230 ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
nuclear@0 1231 (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
nuclear@0 1232 {
nuclear@0 1233 info_ptr->channels++;
nuclear@0 1234 /* if adding a true alpha channel not just filler */
nuclear@0 1235 #if !defined(PNG_1_0_X)
nuclear@0 1236 if (png_ptr->transformations & PNG_ADD_ALPHA)
nuclear@0 1237 info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
nuclear@0 1238 #endif
nuclear@0 1239 }
nuclear@0 1240 #endif
nuclear@0 1241
nuclear@0 1242 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
nuclear@0 1243 defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
nuclear@0 1244 if (png_ptr->transformations & PNG_USER_TRANSFORM)
nuclear@0 1245 {
nuclear@0 1246 if (info_ptr->bit_depth < png_ptr->user_transform_depth)
nuclear@0 1247 info_ptr->bit_depth = png_ptr->user_transform_depth;
nuclear@0 1248 if (info_ptr->channels < png_ptr->user_transform_channels)
nuclear@0 1249 info_ptr->channels = png_ptr->user_transform_channels;
nuclear@0 1250 }
nuclear@0 1251 #endif
nuclear@0 1252
nuclear@0 1253 info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
nuclear@0 1254 info_ptr->bit_depth);
nuclear@0 1255
nuclear@0 1256 info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
nuclear@0 1257
nuclear@0 1258 #if !defined(PNG_READ_EXPAND_SUPPORTED)
nuclear@0 1259 if (png_ptr)
nuclear@0 1260 return;
nuclear@0 1261 #endif
nuclear@0 1262 }
nuclear@0 1263
nuclear@0 1264 /* Transform the row. The order of transformations is significant,
nuclear@0 1265 * and is very touchy. If you add a transformation, take care to
nuclear@0 1266 * decide how it fits in with the other transformations here.
nuclear@0 1267 */
nuclear@0 1268 void /* PRIVATE */
nuclear@0 1269 png_do_read_transformations(png_structp png_ptr)
nuclear@0 1270 {
nuclear@0 1271 png_debug(1, "in png_do_read_transformations\n");
nuclear@0 1272 if (png_ptr->row_buf == NULL)
nuclear@0 1273 {
nuclear@0 1274 #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
nuclear@0 1275 char msg[50];
nuclear@0 1276
nuclear@0 1277 png_snprintf2(msg, 50,
nuclear@0 1278 "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,
nuclear@0 1279 png_ptr->pass);
nuclear@0 1280 png_error(png_ptr, msg);
nuclear@0 1281 #else
nuclear@0 1282 png_error(png_ptr, "NULL row buffer");
nuclear@0 1283 #endif
nuclear@0 1284 }
nuclear@0 1285 #ifdef PNG_WARN_UNINITIALIZED_ROW
nuclear@0 1286 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
nuclear@0 1287 /* Application has failed to call either png_read_start_image()
nuclear@0 1288 * or png_read_update_info() after setting transforms that expand
nuclear@0 1289 * pixels. This check added to libpng-1.2.19 */
nuclear@0 1290 #if (PNG_WARN_UNINITIALIZED_ROW==1)
nuclear@0 1291 png_error(png_ptr, "Uninitialized row");
nuclear@0 1292 #else
nuclear@0 1293 png_warning(png_ptr, "Uninitialized row");
nuclear@0 1294 #endif
nuclear@0 1295 #endif
nuclear@0 1296
nuclear@0 1297 #if defined(PNG_READ_EXPAND_SUPPORTED)
nuclear@0 1298 if (png_ptr->transformations & PNG_EXPAND)
nuclear@0 1299 {
nuclear@0 1300 if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 1301 {
nuclear@0 1302 png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1303 png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
nuclear@0 1304 }
nuclear@0 1305 else
nuclear@0 1306 {
nuclear@0 1307 if (png_ptr->num_trans &&
nuclear@0 1308 (png_ptr->transformations & PNG_EXPAND_tRNS))
nuclear@0 1309 png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1310 &(png_ptr->trans_values));
nuclear@0 1311 else
nuclear@0 1312 png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1313 NULL);
nuclear@0 1314 }
nuclear@0 1315 }
nuclear@0 1316 #endif
nuclear@0 1317
nuclear@0 1318 #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
nuclear@0 1319 if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
nuclear@0 1320 png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1321 PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));
nuclear@0 1322 #endif
nuclear@0 1323
nuclear@0 1324 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
nuclear@0 1325 if (png_ptr->transformations & PNG_RGB_TO_GRAY)
nuclear@0 1326 {
nuclear@0 1327 int rgb_error =
nuclear@0 1328 png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1329 if (rgb_error)
nuclear@0 1330 {
nuclear@0 1331 png_ptr->rgb_to_gray_status=1;
nuclear@0 1332 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
nuclear@0 1333 PNG_RGB_TO_GRAY_WARN)
nuclear@0 1334 png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
nuclear@0 1335 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
nuclear@0 1336 PNG_RGB_TO_GRAY_ERR)
nuclear@0 1337 png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
nuclear@0 1338 }
nuclear@0 1339 }
nuclear@0 1340 #endif
nuclear@0 1341
nuclear@0 1342 /*
nuclear@0 1343 From Andreas Dilger e-mail to png-implement, 26 March 1998:
nuclear@0 1344
nuclear@0 1345 In most cases, the "simple transparency" should be done prior to doing
nuclear@0 1346 gray-to-RGB, or you will have to test 3x as many bytes to check if a
nuclear@0 1347 pixel is transparent. You would also need to make sure that the
nuclear@0 1348 transparency information is upgraded to RGB.
nuclear@0 1349
nuclear@0 1350 To summarize, the current flow is:
nuclear@0 1351 - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
nuclear@0 1352 with background "in place" if transparent,
nuclear@0 1353 convert to RGB if necessary
nuclear@0 1354 - Gray + alpha -> composite with gray background and remove alpha bytes,
nuclear@0 1355 convert to RGB if necessary
nuclear@0 1356
nuclear@0 1357 To support RGB backgrounds for gray images we need:
nuclear@0 1358 - Gray + simple transparency -> convert to RGB + simple transparency, compare
nuclear@0 1359 3 or 6 bytes and composite with background
nuclear@0 1360 "in place" if transparent (3x compare/pixel
nuclear@0 1361 compared to doing composite with gray bkgrnd)
nuclear@0 1362 - Gray + alpha -> convert to RGB + alpha, composite with background and
nuclear@0 1363 remove alpha bytes (3x float operations/pixel
nuclear@0 1364 compared with composite on gray background)
nuclear@0 1365
nuclear@0 1366 Greg's change will do this. The reason it wasn't done before is for
nuclear@0 1367 performance, as this increases the per-pixel operations. If we would check
nuclear@0 1368 in advance if the background was gray or RGB, and position the gray-to-RGB
nuclear@0 1369 transform appropriately, then it would save a lot of work/time.
nuclear@0 1370 */
nuclear@0 1371
nuclear@0 1372 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
nuclear@0 1373 /* if gray -> RGB, do so now only if background is non-gray; else do later
nuclear@0 1374 * for performance reasons */
nuclear@0 1375 if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
nuclear@0 1376 !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
nuclear@0 1377 png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1378 #endif
nuclear@0 1379
nuclear@0 1380 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 1381 if ((png_ptr->transformations & PNG_BACKGROUND) &&
nuclear@0 1382 ((png_ptr->num_trans != 0 ) ||
nuclear@0 1383 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
nuclear@0 1384 png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1385 &(png_ptr->trans_values), &(png_ptr->background)
nuclear@0 1386 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 1387 , &(png_ptr->background_1),
nuclear@0 1388 png_ptr->gamma_table, png_ptr->gamma_from_1,
nuclear@0 1389 png_ptr->gamma_to_1, png_ptr->gamma_16_table,
nuclear@0 1390 png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
nuclear@0 1391 png_ptr->gamma_shift
nuclear@0 1392 #endif
nuclear@0 1393 );
nuclear@0 1394 #endif
nuclear@0 1395
nuclear@0 1396 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 1397 if ((png_ptr->transformations & PNG_GAMMA) &&
nuclear@0 1398 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 1399 !((png_ptr->transformations & PNG_BACKGROUND) &&
nuclear@0 1400 ((png_ptr->num_trans != 0) ||
nuclear@0 1401 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
nuclear@0 1402 #endif
nuclear@0 1403 (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
nuclear@0 1404 png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1405 png_ptr->gamma_table, png_ptr->gamma_16_table,
nuclear@0 1406 png_ptr->gamma_shift);
nuclear@0 1407 #endif
nuclear@0 1408
nuclear@0 1409 #if defined(PNG_READ_16_TO_8_SUPPORTED)
nuclear@0 1410 if (png_ptr->transformations & PNG_16_TO_8)
nuclear@0 1411 png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1412 #endif
nuclear@0 1413
nuclear@0 1414 #if defined(PNG_READ_DITHER_SUPPORTED)
nuclear@0 1415 if (png_ptr->transformations & PNG_DITHER)
nuclear@0 1416 {
nuclear@0 1417 png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1418 png_ptr->palette_lookup, png_ptr->dither_index);
nuclear@0 1419 if (png_ptr->row_info.rowbytes == (png_uint_32)0)
nuclear@0 1420 png_error(png_ptr, "png_do_dither returned rowbytes=0");
nuclear@0 1421 }
nuclear@0 1422 #endif
nuclear@0 1423
nuclear@0 1424 #if defined(PNG_READ_INVERT_SUPPORTED)
nuclear@0 1425 if (png_ptr->transformations & PNG_INVERT_MONO)
nuclear@0 1426 png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1427 #endif
nuclear@0 1428
nuclear@0 1429 #if defined(PNG_READ_SHIFT_SUPPORTED)
nuclear@0 1430 if (png_ptr->transformations & PNG_SHIFT)
nuclear@0 1431 png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1432 &(png_ptr->shift));
nuclear@0 1433 #endif
nuclear@0 1434
nuclear@0 1435 #if defined(PNG_READ_PACK_SUPPORTED)
nuclear@0 1436 if (png_ptr->transformations & PNG_PACK)
nuclear@0 1437 png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1438 #endif
nuclear@0 1439
nuclear@0 1440 #if defined(PNG_READ_BGR_SUPPORTED)
nuclear@0 1441 if (png_ptr->transformations & PNG_BGR)
nuclear@0 1442 png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1443 #endif
nuclear@0 1444
nuclear@0 1445 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
nuclear@0 1446 if (png_ptr->transformations & PNG_PACKSWAP)
nuclear@0 1447 png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1448 #endif
nuclear@0 1449
nuclear@0 1450 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
nuclear@0 1451 /* if gray -> RGB, do so now only if we did not do so above */
nuclear@0 1452 if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
nuclear@0 1453 (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
nuclear@0 1454 png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1455 #endif
nuclear@0 1456
nuclear@0 1457 #if defined(PNG_READ_FILLER_SUPPORTED)
nuclear@0 1458 if (png_ptr->transformations & PNG_FILLER)
nuclear@0 1459 png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
nuclear@0 1460 (png_uint_32)png_ptr->filler, png_ptr->flags);
nuclear@0 1461 #endif
nuclear@0 1462
nuclear@0 1463 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
nuclear@0 1464 if (png_ptr->transformations & PNG_INVERT_ALPHA)
nuclear@0 1465 png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1466 #endif
nuclear@0 1467
nuclear@0 1468 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
nuclear@0 1469 if (png_ptr->transformations & PNG_SWAP_ALPHA)
nuclear@0 1470 png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1471 #endif
nuclear@0 1472
nuclear@0 1473 #if defined(PNG_READ_SWAP_SUPPORTED)
nuclear@0 1474 if (png_ptr->transformations & PNG_SWAP_BYTES)
nuclear@0 1475 png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
nuclear@0 1476 #endif
nuclear@0 1477
nuclear@0 1478 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
nuclear@0 1479 if (png_ptr->transformations & PNG_USER_TRANSFORM)
nuclear@0 1480 {
nuclear@0 1481 if (png_ptr->read_user_transform_fn != NULL)
nuclear@0 1482 (*(png_ptr->read_user_transform_fn)) /* user read transform function */
nuclear@0 1483 (png_ptr, /* png_ptr */
nuclear@0 1484 &(png_ptr->row_info), /* row_info: */
nuclear@0 1485 /* png_uint_32 width; width of row */
nuclear@0 1486 /* png_uint_32 rowbytes; number of bytes in row */
nuclear@0 1487 /* png_byte color_type; color type of pixels */
nuclear@0 1488 /* png_byte bit_depth; bit depth of samples */
nuclear@0 1489 /* png_byte channels; number of channels (1-4) */
nuclear@0 1490 /* png_byte pixel_depth; bits per pixel (depth*channels) */
nuclear@0 1491 png_ptr->row_buf + 1); /* start of pixel data for row */
nuclear@0 1492 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
nuclear@0 1493 if (png_ptr->user_transform_depth)
nuclear@0 1494 png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
nuclear@0 1495 if (png_ptr->user_transform_channels)
nuclear@0 1496 png_ptr->row_info.channels = png_ptr->user_transform_channels;
nuclear@0 1497 #endif
nuclear@0 1498 png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
nuclear@0 1499 png_ptr->row_info.channels);
nuclear@0 1500 png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
nuclear@0 1501 png_ptr->row_info.width);
nuclear@0 1502 }
nuclear@0 1503 #endif
nuclear@0 1504
nuclear@0 1505 }
nuclear@0 1506
nuclear@0 1507 #if defined(PNG_READ_PACK_SUPPORTED)
nuclear@0 1508 /* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
nuclear@0 1509 * without changing the actual values. Thus, if you had a row with
nuclear@0 1510 * a bit depth of 1, you would end up with bytes that only contained
nuclear@0 1511 * the numbers 0 or 1. If you would rather they contain 0 and 255, use
nuclear@0 1512 * png_do_shift() after this.
nuclear@0 1513 */
nuclear@0 1514 void /* PRIVATE */
nuclear@0 1515 png_do_unpack(png_row_infop row_info, png_bytep row)
nuclear@0 1516 {
nuclear@0 1517 png_debug(1, "in png_do_unpack\n");
nuclear@0 1518 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 1519 if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
nuclear@0 1520 #else
nuclear@0 1521 if (row_info->bit_depth < 8)
nuclear@0 1522 #endif
nuclear@0 1523 {
nuclear@0 1524 png_uint_32 i;
nuclear@0 1525 png_uint_32 row_width=row_info->width;
nuclear@0 1526
nuclear@0 1527 switch (row_info->bit_depth)
nuclear@0 1528 {
nuclear@0 1529 case 1:
nuclear@0 1530 {
nuclear@0 1531 png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
nuclear@0 1532 png_bytep dp = row + (png_size_t)row_width - 1;
nuclear@0 1533 png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);
nuclear@0 1534 for (i = 0; i < row_width; i++)
nuclear@0 1535 {
nuclear@0 1536 *dp = (png_byte)((*sp >> shift) & 0x01);
nuclear@0 1537 if (shift == 7)
nuclear@0 1538 {
nuclear@0 1539 shift = 0;
nuclear@0 1540 sp--;
nuclear@0 1541 }
nuclear@0 1542 else
nuclear@0 1543 shift++;
nuclear@0 1544
nuclear@0 1545 dp--;
nuclear@0 1546 }
nuclear@0 1547 break;
nuclear@0 1548 }
nuclear@0 1549 case 2:
nuclear@0 1550 {
nuclear@0 1551
nuclear@0 1552 png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
nuclear@0 1553 png_bytep dp = row + (png_size_t)row_width - 1;
nuclear@0 1554 png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
nuclear@0 1555 for (i = 0; i < row_width; i++)
nuclear@0 1556 {
nuclear@0 1557 *dp = (png_byte)((*sp >> shift) & 0x03);
nuclear@0 1558 if (shift == 6)
nuclear@0 1559 {
nuclear@0 1560 shift = 0;
nuclear@0 1561 sp--;
nuclear@0 1562 }
nuclear@0 1563 else
nuclear@0 1564 shift += 2;
nuclear@0 1565
nuclear@0 1566 dp--;
nuclear@0 1567 }
nuclear@0 1568 break;
nuclear@0 1569 }
nuclear@0 1570 case 4:
nuclear@0 1571 {
nuclear@0 1572 png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
nuclear@0 1573 png_bytep dp = row + (png_size_t)row_width - 1;
nuclear@0 1574 png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
nuclear@0 1575 for (i = 0; i < row_width; i++)
nuclear@0 1576 {
nuclear@0 1577 *dp = (png_byte)((*sp >> shift) & 0x0f);
nuclear@0 1578 if (shift == 4)
nuclear@0 1579 {
nuclear@0 1580 shift = 0;
nuclear@0 1581 sp--;
nuclear@0 1582 }
nuclear@0 1583 else
nuclear@0 1584 shift = 4;
nuclear@0 1585
nuclear@0 1586 dp--;
nuclear@0 1587 }
nuclear@0 1588 break;
nuclear@0 1589 }
nuclear@0 1590 }
nuclear@0 1591 row_info->bit_depth = 8;
nuclear@0 1592 row_info->pixel_depth = (png_byte)(8 * row_info->channels);
nuclear@0 1593 row_info->rowbytes = row_width * row_info->channels;
nuclear@0 1594 }
nuclear@0 1595 }
nuclear@0 1596 #endif
nuclear@0 1597
nuclear@0 1598 #if defined(PNG_READ_SHIFT_SUPPORTED)
nuclear@0 1599 /* Reverse the effects of png_do_shift. This routine merely shifts the
nuclear@0 1600 * pixels back to their significant bits values. Thus, if you have
nuclear@0 1601 * a row of bit depth 8, but only 5 are significant, this will shift
nuclear@0 1602 * the values back to 0 through 31.
nuclear@0 1603 */
nuclear@0 1604 void /* PRIVATE */
nuclear@0 1605 png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
nuclear@0 1606 {
nuclear@0 1607 png_debug(1, "in png_do_unshift\n");
nuclear@0 1608 if (
nuclear@0 1609 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 1610 row != NULL && row_info != NULL && sig_bits != NULL &&
nuclear@0 1611 #endif
nuclear@0 1612 row_info->color_type != PNG_COLOR_TYPE_PALETTE)
nuclear@0 1613 {
nuclear@0 1614 int shift[4];
nuclear@0 1615 int channels = 0;
nuclear@0 1616 int c;
nuclear@0 1617 png_uint_16 value = 0;
nuclear@0 1618 png_uint_32 row_width = row_info->width;
nuclear@0 1619
nuclear@0 1620 if (row_info->color_type & PNG_COLOR_MASK_COLOR)
nuclear@0 1621 {
nuclear@0 1622 shift[channels++] = row_info->bit_depth - sig_bits->red;
nuclear@0 1623 shift[channels++] = row_info->bit_depth - sig_bits->green;
nuclear@0 1624 shift[channels++] = row_info->bit_depth - sig_bits->blue;
nuclear@0 1625 }
nuclear@0 1626 else
nuclear@0 1627 {
nuclear@0 1628 shift[channels++] = row_info->bit_depth - sig_bits->gray;
nuclear@0 1629 }
nuclear@0 1630 if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
nuclear@0 1631 {
nuclear@0 1632 shift[channels++] = row_info->bit_depth - sig_bits->alpha;
nuclear@0 1633 }
nuclear@0 1634
nuclear@0 1635 for (c = 0; c < channels; c++)
nuclear@0 1636 {
nuclear@0 1637 if (shift[c] <= 0)
nuclear@0 1638 shift[c] = 0;
nuclear@0 1639 else
nuclear@0 1640 value = 1;
nuclear@0 1641 }
nuclear@0 1642
nuclear@0 1643 if (!value)
nuclear@0 1644 return;
nuclear@0 1645
nuclear@0 1646 switch (row_info->bit_depth)
nuclear@0 1647 {
nuclear@0 1648 case 2:
nuclear@0 1649 {
nuclear@0 1650 png_bytep bp;
nuclear@0 1651 png_uint_32 i;
nuclear@0 1652 png_uint_32 istop = row_info->rowbytes;
nuclear@0 1653
nuclear@0 1654 for (bp = row, i = 0; i < istop; i++)
nuclear@0 1655 {
nuclear@0 1656 *bp >>= 1;
nuclear@0 1657 *bp++ &= 0x55;
nuclear@0 1658 }
nuclear@0 1659 break;
nuclear@0 1660 }
nuclear@0 1661 case 4:
nuclear@0 1662 {
nuclear@0 1663 png_bytep bp = row;
nuclear@0 1664 png_uint_32 i;
nuclear@0 1665 png_uint_32 istop = row_info->rowbytes;
nuclear@0 1666 png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |
nuclear@0 1667 (png_byte)((int)0xf >> shift[0]));
nuclear@0 1668
nuclear@0 1669 for (i = 0; i < istop; i++)
nuclear@0 1670 {
nuclear@0 1671 *bp >>= shift[0];
nuclear@0 1672 *bp++ &= mask;
nuclear@0 1673 }
nuclear@0 1674 break;
nuclear@0 1675 }
nuclear@0 1676 case 8:
nuclear@0 1677 {
nuclear@0 1678 png_bytep bp = row;
nuclear@0 1679 png_uint_32 i;
nuclear@0 1680 png_uint_32 istop = row_width * channels;
nuclear@0 1681
nuclear@0 1682 for (i = 0; i < istop; i++)
nuclear@0 1683 {
nuclear@0 1684 *bp++ >>= shift[i%channels];
nuclear@0 1685 }
nuclear@0 1686 break;
nuclear@0 1687 }
nuclear@0 1688 case 16:
nuclear@0 1689 {
nuclear@0 1690 png_bytep bp = row;
nuclear@0 1691 png_uint_32 i;
nuclear@0 1692 png_uint_32 istop = channels * row_width;
nuclear@0 1693
nuclear@0 1694 for (i = 0; i < istop; i++)
nuclear@0 1695 {
nuclear@0 1696 value = (png_uint_16)((*bp << 8) + *(bp + 1));
nuclear@0 1697 value >>= shift[i%channels];
nuclear@0 1698 *bp++ = (png_byte)(value >> 8);
nuclear@0 1699 *bp++ = (png_byte)(value & 0xff);
nuclear@0 1700 }
nuclear@0 1701 break;
nuclear@0 1702 }
nuclear@0 1703 }
nuclear@0 1704 }
nuclear@0 1705 }
nuclear@0 1706 #endif
nuclear@0 1707
nuclear@0 1708 #if defined(PNG_READ_16_TO_8_SUPPORTED)
nuclear@0 1709 /* chop rows of bit depth 16 down to 8 */
nuclear@0 1710 void /* PRIVATE */
nuclear@0 1711 png_do_chop(png_row_infop row_info, png_bytep row)
nuclear@0 1712 {
nuclear@0 1713 png_debug(1, "in png_do_chop\n");
nuclear@0 1714 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 1715 if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
nuclear@0 1716 #else
nuclear@0 1717 if (row_info->bit_depth == 16)
nuclear@0 1718 #endif
nuclear@0 1719 {
nuclear@0 1720 png_bytep sp = row;
nuclear@0 1721 png_bytep dp = row;
nuclear@0 1722 png_uint_32 i;
nuclear@0 1723 png_uint_32 istop = row_info->width * row_info->channels;
nuclear@0 1724
nuclear@0 1725 for (i = 0; i<istop; i++, sp += 2, dp++)
nuclear@0 1726 {
nuclear@0 1727 #if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)
nuclear@0 1728 /* This does a more accurate scaling of the 16-bit color
nuclear@0 1729 * value, rather than a simple low-byte truncation.
nuclear@0 1730 *
nuclear@0 1731 * What the ideal calculation should be:
nuclear@0 1732 * *dp = (((((png_uint_32)(*sp) << 8) |
nuclear@0 1733 * (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;
nuclear@0 1734 *
nuclear@0 1735 * GRR: no, I think this is what it really should be:
nuclear@0 1736 * *dp = (((((png_uint_32)(*sp) << 8) |
nuclear@0 1737 * (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;
nuclear@0 1738 *
nuclear@0 1739 * GRR: here's the exact calculation with shifts:
nuclear@0 1740 * temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L;
nuclear@0 1741 * *dp = (temp - (temp >> 8)) >> 8;
nuclear@0 1742 *
nuclear@0 1743 * Approximate calculation with shift/add instead of multiply/divide:
nuclear@0 1744 * *dp = ((((png_uint_32)(*sp) << 8) |
nuclear@0 1745 * (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;
nuclear@0 1746 *
nuclear@0 1747 * What we actually do to avoid extra shifting and conversion:
nuclear@0 1748 */
nuclear@0 1749
nuclear@0 1750 *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);
nuclear@0 1751 #else
nuclear@0 1752 /* Simply discard the low order byte */
nuclear@0 1753 *dp = *sp;
nuclear@0 1754 #endif
nuclear@0 1755 }
nuclear@0 1756 row_info->bit_depth = 8;
nuclear@0 1757 row_info->pixel_depth = (png_byte)(8 * row_info->channels);
nuclear@0 1758 row_info->rowbytes = row_info->width * row_info->channels;
nuclear@0 1759 }
nuclear@0 1760 }
nuclear@0 1761 #endif
nuclear@0 1762
nuclear@0 1763 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
nuclear@0 1764 void /* PRIVATE */
nuclear@0 1765 png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
nuclear@0 1766 {
nuclear@0 1767 png_debug(1, "in png_do_read_swap_alpha\n");
nuclear@0 1768 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 1769 if (row != NULL && row_info != NULL)
nuclear@0 1770 #endif
nuclear@0 1771 {
nuclear@0 1772 png_uint_32 row_width = row_info->width;
nuclear@0 1773 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
nuclear@0 1774 {
nuclear@0 1775 /* This converts from RGBA to ARGB */
nuclear@0 1776 if (row_info->bit_depth == 8)
nuclear@0 1777 {
nuclear@0 1778 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1779 png_bytep dp = sp;
nuclear@0 1780 png_byte save;
nuclear@0 1781 png_uint_32 i;
nuclear@0 1782
nuclear@0 1783 for (i = 0; i < row_width; i++)
nuclear@0 1784 {
nuclear@0 1785 save = *(--sp);
nuclear@0 1786 *(--dp) = *(--sp);
nuclear@0 1787 *(--dp) = *(--sp);
nuclear@0 1788 *(--dp) = *(--sp);
nuclear@0 1789 *(--dp) = save;
nuclear@0 1790 }
nuclear@0 1791 }
nuclear@0 1792 /* This converts from RRGGBBAA to AARRGGBB */
nuclear@0 1793 else
nuclear@0 1794 {
nuclear@0 1795 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1796 png_bytep dp = sp;
nuclear@0 1797 png_byte save[2];
nuclear@0 1798 png_uint_32 i;
nuclear@0 1799
nuclear@0 1800 for (i = 0; i < row_width; i++)
nuclear@0 1801 {
nuclear@0 1802 save[0] = *(--sp);
nuclear@0 1803 save[1] = *(--sp);
nuclear@0 1804 *(--dp) = *(--sp);
nuclear@0 1805 *(--dp) = *(--sp);
nuclear@0 1806 *(--dp) = *(--sp);
nuclear@0 1807 *(--dp) = *(--sp);
nuclear@0 1808 *(--dp) = *(--sp);
nuclear@0 1809 *(--dp) = *(--sp);
nuclear@0 1810 *(--dp) = save[0];
nuclear@0 1811 *(--dp) = save[1];
nuclear@0 1812 }
nuclear@0 1813 }
nuclear@0 1814 }
nuclear@0 1815 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
nuclear@0 1816 {
nuclear@0 1817 /* This converts from GA to AG */
nuclear@0 1818 if (row_info->bit_depth == 8)
nuclear@0 1819 {
nuclear@0 1820 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1821 png_bytep dp = sp;
nuclear@0 1822 png_byte save;
nuclear@0 1823 png_uint_32 i;
nuclear@0 1824
nuclear@0 1825 for (i = 0; i < row_width; i++)
nuclear@0 1826 {
nuclear@0 1827 save = *(--sp);
nuclear@0 1828 *(--dp) = *(--sp);
nuclear@0 1829 *(--dp) = save;
nuclear@0 1830 }
nuclear@0 1831 }
nuclear@0 1832 /* This converts from GGAA to AAGG */
nuclear@0 1833 else
nuclear@0 1834 {
nuclear@0 1835 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1836 png_bytep dp = sp;
nuclear@0 1837 png_byte save[2];
nuclear@0 1838 png_uint_32 i;
nuclear@0 1839
nuclear@0 1840 for (i = 0; i < row_width; i++)
nuclear@0 1841 {
nuclear@0 1842 save[0] = *(--sp);
nuclear@0 1843 save[1] = *(--sp);
nuclear@0 1844 *(--dp) = *(--sp);
nuclear@0 1845 *(--dp) = *(--sp);
nuclear@0 1846 *(--dp) = save[0];
nuclear@0 1847 *(--dp) = save[1];
nuclear@0 1848 }
nuclear@0 1849 }
nuclear@0 1850 }
nuclear@0 1851 }
nuclear@0 1852 }
nuclear@0 1853 #endif
nuclear@0 1854
nuclear@0 1855 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
nuclear@0 1856 void /* PRIVATE */
nuclear@0 1857 png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
nuclear@0 1858 {
nuclear@0 1859 png_debug(1, "in png_do_read_invert_alpha\n");
nuclear@0 1860 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 1861 if (row != NULL && row_info != NULL)
nuclear@0 1862 #endif
nuclear@0 1863 {
nuclear@0 1864 png_uint_32 row_width = row_info->width;
nuclear@0 1865 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
nuclear@0 1866 {
nuclear@0 1867 /* This inverts the alpha channel in RGBA */
nuclear@0 1868 if (row_info->bit_depth == 8)
nuclear@0 1869 {
nuclear@0 1870 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1871 png_bytep dp = sp;
nuclear@0 1872 png_uint_32 i;
nuclear@0 1873
nuclear@0 1874 for (i = 0; i < row_width; i++)
nuclear@0 1875 {
nuclear@0 1876 *(--dp) = (png_byte)(255 - *(--sp));
nuclear@0 1877
nuclear@0 1878 /* This does nothing:
nuclear@0 1879 *(--dp) = *(--sp);
nuclear@0 1880 *(--dp) = *(--sp);
nuclear@0 1881 *(--dp) = *(--sp);
nuclear@0 1882 We can replace it with:
nuclear@0 1883 */
nuclear@0 1884 sp-=3;
nuclear@0 1885 dp=sp;
nuclear@0 1886 }
nuclear@0 1887 }
nuclear@0 1888 /* This inverts the alpha channel in RRGGBBAA */
nuclear@0 1889 else
nuclear@0 1890 {
nuclear@0 1891 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1892 png_bytep dp = sp;
nuclear@0 1893 png_uint_32 i;
nuclear@0 1894
nuclear@0 1895 for (i = 0; i < row_width; i++)
nuclear@0 1896 {
nuclear@0 1897 *(--dp) = (png_byte)(255 - *(--sp));
nuclear@0 1898 *(--dp) = (png_byte)(255 - *(--sp));
nuclear@0 1899
nuclear@0 1900 /* This does nothing:
nuclear@0 1901 *(--dp) = *(--sp);
nuclear@0 1902 *(--dp) = *(--sp);
nuclear@0 1903 *(--dp) = *(--sp);
nuclear@0 1904 *(--dp) = *(--sp);
nuclear@0 1905 *(--dp) = *(--sp);
nuclear@0 1906 *(--dp) = *(--sp);
nuclear@0 1907 We can replace it with:
nuclear@0 1908 */
nuclear@0 1909 sp-=6;
nuclear@0 1910 dp=sp;
nuclear@0 1911 }
nuclear@0 1912 }
nuclear@0 1913 }
nuclear@0 1914 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
nuclear@0 1915 {
nuclear@0 1916 /* This inverts the alpha channel in GA */
nuclear@0 1917 if (row_info->bit_depth == 8)
nuclear@0 1918 {
nuclear@0 1919 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1920 png_bytep dp = sp;
nuclear@0 1921 png_uint_32 i;
nuclear@0 1922
nuclear@0 1923 for (i = 0; i < row_width; i++)
nuclear@0 1924 {
nuclear@0 1925 *(--dp) = (png_byte)(255 - *(--sp));
nuclear@0 1926 *(--dp) = *(--sp);
nuclear@0 1927 }
nuclear@0 1928 }
nuclear@0 1929 /* This inverts the alpha channel in GGAA */
nuclear@0 1930 else
nuclear@0 1931 {
nuclear@0 1932 png_bytep sp = row + row_info->rowbytes;
nuclear@0 1933 png_bytep dp = sp;
nuclear@0 1934 png_uint_32 i;
nuclear@0 1935
nuclear@0 1936 for (i = 0; i < row_width; i++)
nuclear@0 1937 {
nuclear@0 1938 *(--dp) = (png_byte)(255 - *(--sp));
nuclear@0 1939 *(--dp) = (png_byte)(255 - *(--sp));
nuclear@0 1940 /*
nuclear@0 1941 *(--dp) = *(--sp);
nuclear@0 1942 *(--dp) = *(--sp);
nuclear@0 1943 */
nuclear@0 1944 sp-=2;
nuclear@0 1945 dp=sp;
nuclear@0 1946 }
nuclear@0 1947 }
nuclear@0 1948 }
nuclear@0 1949 }
nuclear@0 1950 }
nuclear@0 1951 #endif
nuclear@0 1952
nuclear@0 1953 #if defined(PNG_READ_FILLER_SUPPORTED)
nuclear@0 1954 /* Add filler channel if we have RGB color */
nuclear@0 1955 void /* PRIVATE */
nuclear@0 1956 png_do_read_filler(png_row_infop row_info, png_bytep row,
nuclear@0 1957 png_uint_32 filler, png_uint_32 flags)
nuclear@0 1958 {
nuclear@0 1959 png_uint_32 i;
nuclear@0 1960 png_uint_32 row_width = row_info->width;
nuclear@0 1961
nuclear@0 1962 png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
nuclear@0 1963 png_byte lo_filler = (png_byte)(filler & 0xff);
nuclear@0 1964
nuclear@0 1965 png_debug(1, "in png_do_read_filler\n");
nuclear@0 1966 if (
nuclear@0 1967 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 1968 row != NULL && row_info != NULL &&
nuclear@0 1969 #endif
nuclear@0 1970 row_info->color_type == PNG_COLOR_TYPE_GRAY)
nuclear@0 1971 {
nuclear@0 1972 if (row_info->bit_depth == 8)
nuclear@0 1973 {
nuclear@0 1974 /* This changes the data from G to GX */
nuclear@0 1975 if (flags & PNG_FLAG_FILLER_AFTER)
nuclear@0 1976 {
nuclear@0 1977 png_bytep sp = row + (png_size_t)row_width;
nuclear@0 1978 png_bytep dp = sp + (png_size_t)row_width;
nuclear@0 1979 for (i = 1; i < row_width; i++)
nuclear@0 1980 {
nuclear@0 1981 *(--dp) = lo_filler;
nuclear@0 1982 *(--dp) = *(--sp);
nuclear@0 1983 }
nuclear@0 1984 *(--dp) = lo_filler;
nuclear@0 1985 row_info->channels = 2;
nuclear@0 1986 row_info->pixel_depth = 16;
nuclear@0 1987 row_info->rowbytes = row_width * 2;
nuclear@0 1988 }
nuclear@0 1989 /* This changes the data from G to XG */
nuclear@0 1990 else
nuclear@0 1991 {
nuclear@0 1992 png_bytep sp = row + (png_size_t)row_width;
nuclear@0 1993 png_bytep dp = sp + (png_size_t)row_width;
nuclear@0 1994 for (i = 0; i < row_width; i++)
nuclear@0 1995 {
nuclear@0 1996 *(--dp) = *(--sp);
nuclear@0 1997 *(--dp) = lo_filler;
nuclear@0 1998 }
nuclear@0 1999 row_info->channels = 2;
nuclear@0 2000 row_info->pixel_depth = 16;
nuclear@0 2001 row_info->rowbytes = row_width * 2;
nuclear@0 2002 }
nuclear@0 2003 }
nuclear@0 2004 else if (row_info->bit_depth == 16)
nuclear@0 2005 {
nuclear@0 2006 /* This changes the data from GG to GGXX */
nuclear@0 2007 if (flags & PNG_FLAG_FILLER_AFTER)
nuclear@0 2008 {
nuclear@0 2009 png_bytep sp = row + (png_size_t)row_width * 2;
nuclear@0 2010 png_bytep dp = sp + (png_size_t)row_width * 2;
nuclear@0 2011 for (i = 1; i < row_width; i++)
nuclear@0 2012 {
nuclear@0 2013 *(--dp) = hi_filler;
nuclear@0 2014 *(--dp) = lo_filler;
nuclear@0 2015 *(--dp) = *(--sp);
nuclear@0 2016 *(--dp) = *(--sp);
nuclear@0 2017 }
nuclear@0 2018 *(--dp) = hi_filler;
nuclear@0 2019 *(--dp) = lo_filler;
nuclear@0 2020 row_info->channels = 2;
nuclear@0 2021 row_info->pixel_depth = 32;
nuclear@0 2022 row_info->rowbytes = row_width * 4;
nuclear@0 2023 }
nuclear@0 2024 /* This changes the data from GG to XXGG */
nuclear@0 2025 else
nuclear@0 2026 {
nuclear@0 2027 png_bytep sp = row + (png_size_t)row_width * 2;
nuclear@0 2028 png_bytep dp = sp + (png_size_t)row_width * 2;
nuclear@0 2029 for (i = 0; i < row_width; i++)
nuclear@0 2030 {
nuclear@0 2031 *(--dp) = *(--sp);
nuclear@0 2032 *(--dp) = *(--sp);
nuclear@0 2033 *(--dp) = hi_filler;
nuclear@0 2034 *(--dp) = lo_filler;
nuclear@0 2035 }
nuclear@0 2036 row_info->channels = 2;
nuclear@0 2037 row_info->pixel_depth = 32;
nuclear@0 2038 row_info->rowbytes = row_width * 4;
nuclear@0 2039 }
nuclear@0 2040 }
nuclear@0 2041 } /* COLOR_TYPE == GRAY */
nuclear@0 2042 else if (row_info->color_type == PNG_COLOR_TYPE_RGB)
nuclear@0 2043 {
nuclear@0 2044 if (row_info->bit_depth == 8)
nuclear@0 2045 {
nuclear@0 2046 /* This changes the data from RGB to RGBX */
nuclear@0 2047 if (flags & PNG_FLAG_FILLER_AFTER)
nuclear@0 2048 {
nuclear@0 2049 png_bytep sp = row + (png_size_t)row_width * 3;
nuclear@0 2050 png_bytep dp = sp + (png_size_t)row_width;
nuclear@0 2051 for (i = 1; i < row_width; i++)
nuclear@0 2052 {
nuclear@0 2053 *(--dp) = lo_filler;
nuclear@0 2054 *(--dp) = *(--sp);
nuclear@0 2055 *(--dp) = *(--sp);
nuclear@0 2056 *(--dp) = *(--sp);
nuclear@0 2057 }
nuclear@0 2058 *(--dp) = lo_filler;
nuclear@0 2059 row_info->channels = 4;
nuclear@0 2060 row_info->pixel_depth = 32;
nuclear@0 2061 row_info->rowbytes = row_width * 4;
nuclear@0 2062 }
nuclear@0 2063 /* This changes the data from RGB to XRGB */
nuclear@0 2064 else
nuclear@0 2065 {
nuclear@0 2066 png_bytep sp = row + (png_size_t)row_width * 3;
nuclear@0 2067 png_bytep dp = sp + (png_size_t)row_width;
nuclear@0 2068 for (i = 0; i < row_width; i++)
nuclear@0 2069 {
nuclear@0 2070 *(--dp) = *(--sp);
nuclear@0 2071 *(--dp) = *(--sp);
nuclear@0 2072 *(--dp) = *(--sp);
nuclear@0 2073 *(--dp) = lo_filler;
nuclear@0 2074 }
nuclear@0 2075 row_info->channels = 4;
nuclear@0 2076 row_info->pixel_depth = 32;
nuclear@0 2077 row_info->rowbytes = row_width * 4;
nuclear@0 2078 }
nuclear@0 2079 }
nuclear@0 2080 else if (row_info->bit_depth == 16)
nuclear@0 2081 {
nuclear@0 2082 /* This changes the data from RRGGBB to RRGGBBXX */
nuclear@0 2083 if (flags & PNG_FLAG_FILLER_AFTER)
nuclear@0 2084 {
nuclear@0 2085 png_bytep sp = row + (png_size_t)row_width * 6;
nuclear@0 2086 png_bytep dp = sp + (png_size_t)row_width * 2;
nuclear@0 2087 for (i = 1; i < row_width; i++)
nuclear@0 2088 {
nuclear@0 2089 *(--dp) = hi_filler;
nuclear@0 2090 *(--dp) = lo_filler;
nuclear@0 2091 *(--dp) = *(--sp);
nuclear@0 2092 *(--dp) = *(--sp);
nuclear@0 2093 *(--dp) = *(--sp);
nuclear@0 2094 *(--dp) = *(--sp);
nuclear@0 2095 *(--dp) = *(--sp);
nuclear@0 2096 *(--dp) = *(--sp);
nuclear@0 2097 }
nuclear@0 2098 *(--dp) = hi_filler;
nuclear@0 2099 *(--dp) = lo_filler;
nuclear@0 2100 row_info->channels = 4;
nuclear@0 2101 row_info->pixel_depth = 64;
nuclear@0 2102 row_info->rowbytes = row_width * 8;
nuclear@0 2103 }
nuclear@0 2104 /* This changes the data from RRGGBB to XXRRGGBB */
nuclear@0 2105 else
nuclear@0 2106 {
nuclear@0 2107 png_bytep sp = row + (png_size_t)row_width * 6;
nuclear@0 2108 png_bytep dp = sp + (png_size_t)row_width * 2;
nuclear@0 2109 for (i = 0; i < row_width; i++)
nuclear@0 2110 {
nuclear@0 2111 *(--dp) = *(--sp);
nuclear@0 2112 *(--dp) = *(--sp);
nuclear@0 2113 *(--dp) = *(--sp);
nuclear@0 2114 *(--dp) = *(--sp);
nuclear@0 2115 *(--dp) = *(--sp);
nuclear@0 2116 *(--dp) = *(--sp);
nuclear@0 2117 *(--dp) = hi_filler;
nuclear@0 2118 *(--dp) = lo_filler;
nuclear@0 2119 }
nuclear@0 2120 row_info->channels = 4;
nuclear@0 2121 row_info->pixel_depth = 64;
nuclear@0 2122 row_info->rowbytes = row_width * 8;
nuclear@0 2123 }
nuclear@0 2124 }
nuclear@0 2125 } /* COLOR_TYPE == RGB */
nuclear@0 2126 }
nuclear@0 2127 #endif
nuclear@0 2128
nuclear@0 2129 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
nuclear@0 2130 /* expand grayscale files to RGB, with or without alpha */
nuclear@0 2131 void /* PRIVATE */
nuclear@0 2132 png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
nuclear@0 2133 {
nuclear@0 2134 png_uint_32 i;
nuclear@0 2135 png_uint_32 row_width = row_info->width;
nuclear@0 2136
nuclear@0 2137 png_debug(1, "in png_do_gray_to_rgb\n");
nuclear@0 2138 if (row_info->bit_depth >= 8 &&
nuclear@0 2139 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 2140 row != NULL && row_info != NULL &&
nuclear@0 2141 #endif
nuclear@0 2142 !(row_info->color_type & PNG_COLOR_MASK_COLOR))
nuclear@0 2143 {
nuclear@0 2144 if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
nuclear@0 2145 {
nuclear@0 2146 if (row_info->bit_depth == 8)
nuclear@0 2147 {
nuclear@0 2148 png_bytep sp = row + (png_size_t)row_width - 1;
nuclear@0 2149 png_bytep dp = sp + (png_size_t)row_width * 2;
nuclear@0 2150 for (i = 0; i < row_width; i++)
nuclear@0 2151 {
nuclear@0 2152 *(dp--) = *sp;
nuclear@0 2153 *(dp--) = *sp;
nuclear@0 2154 *(dp--) = *(sp--);
nuclear@0 2155 }
nuclear@0 2156 }
nuclear@0 2157 else
nuclear@0 2158 {
nuclear@0 2159 png_bytep sp = row + (png_size_t)row_width * 2 - 1;
nuclear@0 2160 png_bytep dp = sp + (png_size_t)row_width * 4;
nuclear@0 2161 for (i = 0; i < row_width; i++)
nuclear@0 2162 {
nuclear@0 2163 *(dp--) = *sp;
nuclear@0 2164 *(dp--) = *(sp - 1);
nuclear@0 2165 *(dp--) = *sp;
nuclear@0 2166 *(dp--) = *(sp - 1);
nuclear@0 2167 *(dp--) = *(sp--);
nuclear@0 2168 *(dp--) = *(sp--);
nuclear@0 2169 }
nuclear@0 2170 }
nuclear@0 2171 }
nuclear@0 2172 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
nuclear@0 2173 {
nuclear@0 2174 if (row_info->bit_depth == 8)
nuclear@0 2175 {
nuclear@0 2176 png_bytep sp = row + (png_size_t)row_width * 2 - 1;
nuclear@0 2177 png_bytep dp = sp + (png_size_t)row_width * 2;
nuclear@0 2178 for (i = 0; i < row_width; i++)
nuclear@0 2179 {
nuclear@0 2180 *(dp--) = *(sp--);
nuclear@0 2181 *(dp--) = *sp;
nuclear@0 2182 *(dp--) = *sp;
nuclear@0 2183 *(dp--) = *(sp--);
nuclear@0 2184 }
nuclear@0 2185 }
nuclear@0 2186 else
nuclear@0 2187 {
nuclear@0 2188 png_bytep sp = row + (png_size_t)row_width * 4 - 1;
nuclear@0 2189 png_bytep dp = sp + (png_size_t)row_width * 4;
nuclear@0 2190 for (i = 0; i < row_width; i++)
nuclear@0 2191 {
nuclear@0 2192 *(dp--) = *(sp--);
nuclear@0 2193 *(dp--) = *(sp--);
nuclear@0 2194 *(dp--) = *sp;
nuclear@0 2195 *(dp--) = *(sp - 1);
nuclear@0 2196 *(dp--) = *sp;
nuclear@0 2197 *(dp--) = *(sp - 1);
nuclear@0 2198 *(dp--) = *(sp--);
nuclear@0 2199 *(dp--) = *(sp--);
nuclear@0 2200 }
nuclear@0 2201 }
nuclear@0 2202 }
nuclear@0 2203 row_info->channels += (png_byte)2;
nuclear@0 2204 row_info->color_type |= PNG_COLOR_MASK_COLOR;
nuclear@0 2205 row_info->pixel_depth = (png_byte)(row_info->channels *
nuclear@0 2206 row_info->bit_depth);
nuclear@0 2207 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
nuclear@0 2208 }
nuclear@0 2209 }
nuclear@0 2210 #endif
nuclear@0 2211
nuclear@0 2212 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
nuclear@0 2213 /* reduce RGB files to grayscale, with or without alpha
nuclear@0 2214 * using the equation given in Poynton's ColorFAQ at
nuclear@0 2215 * <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008)
nuclear@0 2216 * New link:
nuclear@0 2217 * <http://www.poynton.com/notes/colour_and_gamma/>
nuclear@0 2218 * Charles Poynton poynton at poynton.com
nuclear@0 2219 *
nuclear@0 2220 * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B
nuclear@0 2221 *
nuclear@0 2222 * We approximate this with
nuclear@0 2223 *
nuclear@0 2224 * Y = 0.21268 * R + 0.7151 * G + 0.07217 * B
nuclear@0 2225 *
nuclear@0 2226 * which can be expressed with integers as
nuclear@0 2227 *
nuclear@0 2228 * Y = (6969 * R + 23434 * G + 2365 * B)/32768
nuclear@0 2229 *
nuclear@0 2230 * The calculation is to be done in a linear colorspace.
nuclear@0 2231 *
nuclear@0 2232 * Other integer coefficents can be used via png_set_rgb_to_gray().
nuclear@0 2233 */
nuclear@0 2234 int /* PRIVATE */
nuclear@0 2235 png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
nuclear@0 2236
nuclear@0 2237 {
nuclear@0 2238 png_uint_32 i;
nuclear@0 2239
nuclear@0 2240 png_uint_32 row_width = row_info->width;
nuclear@0 2241 int rgb_error = 0;
nuclear@0 2242
nuclear@0 2243 png_debug(1, "in png_do_rgb_to_gray\n");
nuclear@0 2244 if (
nuclear@0 2245 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 2246 row != NULL && row_info != NULL &&
nuclear@0 2247 #endif
nuclear@0 2248 (row_info->color_type & PNG_COLOR_MASK_COLOR))
nuclear@0 2249 {
nuclear@0 2250 png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
nuclear@0 2251 png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
nuclear@0 2252 png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
nuclear@0 2253
nuclear@0 2254 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
nuclear@0 2255 {
nuclear@0 2256 if (row_info->bit_depth == 8)
nuclear@0 2257 {
nuclear@0 2258 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 2259 if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
nuclear@0 2260 {
nuclear@0 2261 png_bytep sp = row;
nuclear@0 2262 png_bytep dp = row;
nuclear@0 2263
nuclear@0 2264 for (i = 0; i < row_width; i++)
nuclear@0 2265 {
nuclear@0 2266 png_byte red = png_ptr->gamma_to_1[*(sp++)];
nuclear@0 2267 png_byte green = png_ptr->gamma_to_1[*(sp++)];
nuclear@0 2268 png_byte blue = png_ptr->gamma_to_1[*(sp++)];
nuclear@0 2269 if (red != green || red != blue)
nuclear@0 2270 {
nuclear@0 2271 rgb_error |= 1;
nuclear@0 2272 *(dp++) = png_ptr->gamma_from_1[
nuclear@0 2273 (rc*red + gc*green + bc*blue)>>15];
nuclear@0 2274 }
nuclear@0 2275 else
nuclear@0 2276 *(dp++) = *(sp - 1);
nuclear@0 2277 }
nuclear@0 2278 }
nuclear@0 2279 else
nuclear@0 2280 #endif
nuclear@0 2281 {
nuclear@0 2282 png_bytep sp = row;
nuclear@0 2283 png_bytep dp = row;
nuclear@0 2284 for (i = 0; i < row_width; i++)
nuclear@0 2285 {
nuclear@0 2286 png_byte red = *(sp++);
nuclear@0 2287 png_byte green = *(sp++);
nuclear@0 2288 png_byte blue = *(sp++);
nuclear@0 2289 if (red != green || red != blue)
nuclear@0 2290 {
nuclear@0 2291 rgb_error |= 1;
nuclear@0 2292 *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
nuclear@0 2293 }
nuclear@0 2294 else
nuclear@0 2295 *(dp++) = *(sp - 1);
nuclear@0 2296 }
nuclear@0 2297 }
nuclear@0 2298 }
nuclear@0 2299
nuclear@0 2300 else /* RGB bit_depth == 16 */
nuclear@0 2301 {
nuclear@0 2302 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 2303 if (png_ptr->gamma_16_to_1 != NULL &&
nuclear@0 2304 png_ptr->gamma_16_from_1 != NULL)
nuclear@0 2305 {
nuclear@0 2306 png_bytep sp = row;
nuclear@0 2307 png_bytep dp = row;
nuclear@0 2308 for (i = 0; i < row_width; i++)
nuclear@0 2309 {
nuclear@0 2310 png_uint_16 red, green, blue, w;
nuclear@0 2311
nuclear@0 2312 red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2313 green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2314 blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2315
nuclear@0 2316 if (red == green && red == blue)
nuclear@0 2317 w = red;
nuclear@0 2318 else
nuclear@0 2319 {
nuclear@0 2320 png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>
nuclear@0 2321 png_ptr->gamma_shift][red>>8];
nuclear@0 2322 png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
nuclear@0 2323 png_ptr->gamma_shift][green>>8];
nuclear@0 2324 png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>
nuclear@0 2325 png_ptr->gamma_shift][blue>>8];
nuclear@0 2326 png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1
nuclear@0 2327 + bc*blue_1)>>15);
nuclear@0 2328 w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
nuclear@0 2329 png_ptr->gamma_shift][gray16 >> 8];
nuclear@0 2330 rgb_error |= 1;
nuclear@0 2331 }
nuclear@0 2332
nuclear@0 2333 *(dp++) = (png_byte)((w>>8) & 0xff);
nuclear@0 2334 *(dp++) = (png_byte)(w & 0xff);
nuclear@0 2335 }
nuclear@0 2336 }
nuclear@0 2337 else
nuclear@0 2338 #endif
nuclear@0 2339 {
nuclear@0 2340 png_bytep sp = row;
nuclear@0 2341 png_bytep dp = row;
nuclear@0 2342 for (i = 0; i < row_width; i++)
nuclear@0 2343 {
nuclear@0 2344 png_uint_16 red, green, blue, gray16;
nuclear@0 2345
nuclear@0 2346 red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2347 green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2348 blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2349
nuclear@0 2350 if (red != green || red != blue)
nuclear@0 2351 rgb_error |= 1;
nuclear@0 2352 gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
nuclear@0 2353 *(dp++) = (png_byte)((gray16>>8) & 0xff);
nuclear@0 2354 *(dp++) = (png_byte)(gray16 & 0xff);
nuclear@0 2355 }
nuclear@0 2356 }
nuclear@0 2357 }
nuclear@0 2358 }
nuclear@0 2359 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
nuclear@0 2360 {
nuclear@0 2361 if (row_info->bit_depth == 8)
nuclear@0 2362 {
nuclear@0 2363 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 2364 if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)
nuclear@0 2365 {
nuclear@0 2366 png_bytep sp = row;
nuclear@0 2367 png_bytep dp = row;
nuclear@0 2368 for (i = 0; i < row_width; i++)
nuclear@0 2369 {
nuclear@0 2370 png_byte red = png_ptr->gamma_to_1[*(sp++)];
nuclear@0 2371 png_byte green = png_ptr->gamma_to_1[*(sp++)];
nuclear@0 2372 png_byte blue = png_ptr->gamma_to_1[*(sp++)];
nuclear@0 2373 if (red != green || red != blue)
nuclear@0 2374 rgb_error |= 1;
nuclear@0 2375 *(dp++) = png_ptr->gamma_from_1
nuclear@0 2376 [(rc*red + gc*green + bc*blue)>>15];
nuclear@0 2377 *(dp++) = *(sp++); /* alpha */
nuclear@0 2378 }
nuclear@0 2379 }
nuclear@0 2380 else
nuclear@0 2381 #endif
nuclear@0 2382 {
nuclear@0 2383 png_bytep sp = row;
nuclear@0 2384 png_bytep dp = row;
nuclear@0 2385 for (i = 0; i < row_width; i++)
nuclear@0 2386 {
nuclear@0 2387 png_byte red = *(sp++);
nuclear@0 2388 png_byte green = *(sp++);
nuclear@0 2389 png_byte blue = *(sp++);
nuclear@0 2390 if (red != green || red != blue)
nuclear@0 2391 rgb_error |= 1;
nuclear@0 2392 *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);
nuclear@0 2393 *(dp++) = *(sp++); /* alpha */
nuclear@0 2394 }
nuclear@0 2395 }
nuclear@0 2396 }
nuclear@0 2397 else /* RGBA bit_depth == 16 */
nuclear@0 2398 {
nuclear@0 2399 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 2400 if (png_ptr->gamma_16_to_1 != NULL &&
nuclear@0 2401 png_ptr->gamma_16_from_1 != NULL)
nuclear@0 2402 {
nuclear@0 2403 png_bytep sp = row;
nuclear@0 2404 png_bytep dp = row;
nuclear@0 2405 for (i = 0; i < row_width; i++)
nuclear@0 2406 {
nuclear@0 2407 png_uint_16 red, green, blue, w;
nuclear@0 2408
nuclear@0 2409 red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2410 green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2411 blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;
nuclear@0 2412
nuclear@0 2413 if (red == green && red == blue)
nuclear@0 2414 w = red;
nuclear@0 2415 else
nuclear@0 2416 {
nuclear@0 2417 png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>
nuclear@0 2418 png_ptr->gamma_shift][red>>8];
nuclear@0 2419 png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>
nuclear@0 2420 png_ptr->gamma_shift][green>>8];
nuclear@0 2421 png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>
nuclear@0 2422 png_ptr->gamma_shift][blue>>8];
nuclear@0 2423 png_uint_16 gray16 = (png_uint_16)((rc * red_1
nuclear@0 2424 + gc * green_1 + bc * blue_1)>>15);
nuclear@0 2425 w = png_ptr->gamma_16_from_1[(gray16&0xff) >>
nuclear@0 2426 png_ptr->gamma_shift][gray16 >> 8];
nuclear@0 2427 rgb_error |= 1;
nuclear@0 2428 }
nuclear@0 2429
nuclear@0 2430 *(dp++) = (png_byte)((w>>8) & 0xff);
nuclear@0 2431 *(dp++) = (png_byte)(w & 0xff);
nuclear@0 2432 *(dp++) = *(sp++); /* alpha */
nuclear@0 2433 *(dp++) = *(sp++);
nuclear@0 2434 }
nuclear@0 2435 }
nuclear@0 2436 else
nuclear@0 2437 #endif
nuclear@0 2438 {
nuclear@0 2439 png_bytep sp = row;
nuclear@0 2440 png_bytep dp = row;
nuclear@0 2441 for (i = 0; i < row_width; i++)
nuclear@0 2442 {
nuclear@0 2443 png_uint_16 red, green, blue, gray16;
nuclear@0 2444 red = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
nuclear@0 2445 green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
nuclear@0 2446 blue = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;
nuclear@0 2447 if (red != green || red != blue)
nuclear@0 2448 rgb_error |= 1;
nuclear@0 2449 gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);
nuclear@0 2450 *(dp++) = (png_byte)((gray16>>8) & 0xff);
nuclear@0 2451 *(dp++) = (png_byte)(gray16 & 0xff);
nuclear@0 2452 *(dp++) = *(sp++); /* alpha */
nuclear@0 2453 *(dp++) = *(sp++);
nuclear@0 2454 }
nuclear@0 2455 }
nuclear@0 2456 }
nuclear@0 2457 }
nuclear@0 2458 row_info->channels -= (png_byte)2;
nuclear@0 2459 row_info->color_type &= ~PNG_COLOR_MASK_COLOR;
nuclear@0 2460 row_info->pixel_depth = (png_byte)(row_info->channels *
nuclear@0 2461 row_info->bit_depth);
nuclear@0 2462 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
nuclear@0 2463 }
nuclear@0 2464 return rgb_error;
nuclear@0 2465 }
nuclear@0 2466 #endif
nuclear@0 2467
nuclear@0 2468 /* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
nuclear@0 2469 * large of png_color. This lets grayscale images be treated as
nuclear@0 2470 * paletted. Most useful for gamma correction and simplification
nuclear@0 2471 * of code.
nuclear@0 2472 */
nuclear@0 2473 void PNGAPI
nuclear@0 2474 png_build_grayscale_palette(int bit_depth, png_colorp palette)
nuclear@0 2475 {
nuclear@0 2476 int num_palette;
nuclear@0 2477 int color_inc;
nuclear@0 2478 int i;
nuclear@0 2479 int v;
nuclear@0 2480
nuclear@0 2481 png_debug(1, "in png_do_build_grayscale_palette\n");
nuclear@0 2482 if (palette == NULL)
nuclear@0 2483 return;
nuclear@0 2484
nuclear@0 2485 switch (bit_depth)
nuclear@0 2486 {
nuclear@0 2487 case 1:
nuclear@0 2488 num_palette = 2;
nuclear@0 2489 color_inc = 0xff;
nuclear@0 2490 break;
nuclear@0 2491 case 2:
nuclear@0 2492 num_palette = 4;
nuclear@0 2493 color_inc = 0x55;
nuclear@0 2494 break;
nuclear@0 2495 case 4:
nuclear@0 2496 num_palette = 16;
nuclear@0 2497 color_inc = 0x11;
nuclear@0 2498 break;
nuclear@0 2499 case 8:
nuclear@0 2500 num_palette = 256;
nuclear@0 2501 color_inc = 1;
nuclear@0 2502 break;
nuclear@0 2503 default:
nuclear@0 2504 num_palette = 0;
nuclear@0 2505 color_inc = 0;
nuclear@0 2506 break;
nuclear@0 2507 }
nuclear@0 2508
nuclear@0 2509 for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
nuclear@0 2510 {
nuclear@0 2511 palette[i].red = (png_byte)v;
nuclear@0 2512 palette[i].green = (png_byte)v;
nuclear@0 2513 palette[i].blue = (png_byte)v;
nuclear@0 2514 }
nuclear@0 2515 }
nuclear@0 2516
nuclear@0 2517 /* This function is currently unused. Do we really need it? */
nuclear@0 2518 #if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
nuclear@0 2519 void /* PRIVATE */
nuclear@0 2520 png_correct_palette(png_structp png_ptr, png_colorp palette,
nuclear@0 2521 int num_palette)
nuclear@0 2522 {
nuclear@0 2523 png_debug(1, "in png_correct_palette\n");
nuclear@0 2524 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
nuclear@0 2525 defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
nuclear@0 2526 if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))
nuclear@0 2527 {
nuclear@0 2528 png_color back, back_1;
nuclear@0 2529
nuclear@0 2530 if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
nuclear@0 2531 {
nuclear@0 2532 back.red = png_ptr->gamma_table[png_ptr->background.red];
nuclear@0 2533 back.green = png_ptr->gamma_table[png_ptr->background.green];
nuclear@0 2534 back.blue = png_ptr->gamma_table[png_ptr->background.blue];
nuclear@0 2535
nuclear@0 2536 back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
nuclear@0 2537 back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
nuclear@0 2538 back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
nuclear@0 2539 }
nuclear@0 2540 else
nuclear@0 2541 {
nuclear@0 2542 double g;
nuclear@0 2543
nuclear@0 2544 g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
nuclear@0 2545
nuclear@0 2546 if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||
nuclear@0 2547 fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
nuclear@0 2548 {
nuclear@0 2549 back.red = png_ptr->background.red;
nuclear@0 2550 back.green = png_ptr->background.green;
nuclear@0 2551 back.blue = png_ptr->background.blue;
nuclear@0 2552 }
nuclear@0 2553 else
nuclear@0 2554 {
nuclear@0 2555 back.red =
nuclear@0 2556 (png_byte)(pow((double)png_ptr->background.red/255, g) *
nuclear@0 2557 255.0 + 0.5);
nuclear@0 2558 back.green =
nuclear@0 2559 (png_byte)(pow((double)png_ptr->background.green/255, g) *
nuclear@0 2560 255.0 + 0.5);
nuclear@0 2561 back.blue =
nuclear@0 2562 (png_byte)(pow((double)png_ptr->background.blue/255, g) *
nuclear@0 2563 255.0 + 0.5);
nuclear@0 2564 }
nuclear@0 2565
nuclear@0 2566 g = 1.0 / png_ptr->background_gamma;
nuclear@0 2567
nuclear@0 2568 back_1.red =
nuclear@0 2569 (png_byte)(pow((double)png_ptr->background.red/255, g) *
nuclear@0 2570 255.0 + 0.5);
nuclear@0 2571 back_1.green =
nuclear@0 2572 (png_byte)(pow((double)png_ptr->background.green/255, g) *
nuclear@0 2573 255.0 + 0.5);
nuclear@0 2574 back_1.blue =
nuclear@0 2575 (png_byte)(pow((double)png_ptr->background.blue/255, g) *
nuclear@0 2576 255.0 + 0.5);
nuclear@0 2577 }
nuclear@0 2578
nuclear@0 2579 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 2580 {
nuclear@0 2581 png_uint_32 i;
nuclear@0 2582
nuclear@0 2583 for (i = 0; i < (png_uint_32)num_palette; i++)
nuclear@0 2584 {
nuclear@0 2585 if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)
nuclear@0 2586 {
nuclear@0 2587 palette[i] = back;
nuclear@0 2588 }
nuclear@0 2589 else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)
nuclear@0 2590 {
nuclear@0 2591 png_byte v, w;
nuclear@0 2592
nuclear@0 2593 v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
nuclear@0 2594 png_composite(w, v, png_ptr->trans[i], back_1.red);
nuclear@0 2595 palette[i].red = png_ptr->gamma_from_1[w];
nuclear@0 2596
nuclear@0 2597 v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
nuclear@0 2598 png_composite(w, v, png_ptr->trans[i], back_1.green);
nuclear@0 2599 palette[i].green = png_ptr->gamma_from_1[w];
nuclear@0 2600
nuclear@0 2601 v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
nuclear@0 2602 png_composite(w, v, png_ptr->trans[i], back_1.blue);
nuclear@0 2603 palette[i].blue = png_ptr->gamma_from_1[w];
nuclear@0 2604 }
nuclear@0 2605 else
nuclear@0 2606 {
nuclear@0 2607 palette[i].red = png_ptr->gamma_table[palette[i].red];
nuclear@0 2608 palette[i].green = png_ptr->gamma_table[palette[i].green];
nuclear@0 2609 palette[i].blue = png_ptr->gamma_table[palette[i].blue];
nuclear@0 2610 }
nuclear@0 2611 }
nuclear@0 2612 }
nuclear@0 2613 else
nuclear@0 2614 {
nuclear@0 2615 int i;
nuclear@0 2616
nuclear@0 2617 for (i = 0; i < num_palette; i++)
nuclear@0 2618 {
nuclear@0 2619 if (palette[i].red == (png_byte)png_ptr->trans_values.gray)
nuclear@0 2620 {
nuclear@0 2621 palette[i] = back;
nuclear@0 2622 }
nuclear@0 2623 else
nuclear@0 2624 {
nuclear@0 2625 palette[i].red = png_ptr->gamma_table[palette[i].red];
nuclear@0 2626 palette[i].green = png_ptr->gamma_table[palette[i].green];
nuclear@0 2627 palette[i].blue = png_ptr->gamma_table[palette[i].blue];
nuclear@0 2628 }
nuclear@0 2629 }
nuclear@0 2630 }
nuclear@0 2631 }
nuclear@0 2632 else
nuclear@0 2633 #endif
nuclear@0 2634 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2635 if (png_ptr->transformations & PNG_GAMMA)
nuclear@0 2636 {
nuclear@0 2637 int i;
nuclear@0 2638
nuclear@0 2639 for (i = 0; i < num_palette; i++)
nuclear@0 2640 {
nuclear@0 2641 palette[i].red = png_ptr->gamma_table[palette[i].red];
nuclear@0 2642 palette[i].green = png_ptr->gamma_table[palette[i].green];
nuclear@0 2643 palette[i].blue = png_ptr->gamma_table[palette[i].blue];
nuclear@0 2644 }
nuclear@0 2645 }
nuclear@0 2646 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 2647 else
nuclear@0 2648 #endif
nuclear@0 2649 #endif
nuclear@0 2650 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 2651 if (png_ptr->transformations & PNG_BACKGROUND)
nuclear@0 2652 {
nuclear@0 2653 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 2654 {
nuclear@0 2655 png_color back;
nuclear@0 2656
nuclear@0 2657 back.red = (png_byte)png_ptr->background.red;
nuclear@0 2658 back.green = (png_byte)png_ptr->background.green;
nuclear@0 2659 back.blue = (png_byte)png_ptr->background.blue;
nuclear@0 2660
nuclear@0 2661 for (i = 0; i < (int)png_ptr->num_trans; i++)
nuclear@0 2662 {
nuclear@0 2663 if (png_ptr->trans[i] == 0)
nuclear@0 2664 {
nuclear@0 2665 palette[i].red = back.red;
nuclear@0 2666 palette[i].green = back.green;
nuclear@0 2667 palette[i].blue = back.blue;
nuclear@0 2668 }
nuclear@0 2669 else if (png_ptr->trans[i] != 0xff)
nuclear@0 2670 {
nuclear@0 2671 png_composite(palette[i].red, png_ptr->palette[i].red,
nuclear@0 2672 png_ptr->trans[i], back.red);
nuclear@0 2673 png_composite(palette[i].green, png_ptr->palette[i].green,
nuclear@0 2674 png_ptr->trans[i], back.green);
nuclear@0 2675 png_composite(palette[i].blue, png_ptr->palette[i].blue,
nuclear@0 2676 png_ptr->trans[i], back.blue);
nuclear@0 2677 }
nuclear@0 2678 }
nuclear@0 2679 }
nuclear@0 2680 else /* assume grayscale palette (what else could it be?) */
nuclear@0 2681 {
nuclear@0 2682 int i;
nuclear@0 2683
nuclear@0 2684 for (i = 0; i < num_palette; i++)
nuclear@0 2685 {
nuclear@0 2686 if (i == (png_byte)png_ptr->trans_values.gray)
nuclear@0 2687 {
nuclear@0 2688 palette[i].red = (png_byte)png_ptr->background.red;
nuclear@0 2689 palette[i].green = (png_byte)png_ptr->background.green;
nuclear@0 2690 palette[i].blue = (png_byte)png_ptr->background.blue;
nuclear@0 2691 }
nuclear@0 2692 }
nuclear@0 2693 }
nuclear@0 2694 }
nuclear@0 2695 #endif
nuclear@0 2696 }
nuclear@0 2697 #endif
nuclear@0 2698
nuclear@0 2699 #if defined(PNG_READ_BACKGROUND_SUPPORTED)
nuclear@0 2700 /* Replace any alpha or transparency with the supplied background color.
nuclear@0 2701 * "background" is already in the screen gamma, while "background_1" is
nuclear@0 2702 * at a gamma of 1.0. Paletted files have already been taken care of.
nuclear@0 2703 */
nuclear@0 2704 void /* PRIVATE */
nuclear@0 2705 png_do_background(png_row_infop row_info, png_bytep row,
nuclear@0 2706 png_color_16p trans_values, png_color_16p background
nuclear@0 2707 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2708 , png_color_16p background_1,
nuclear@0 2709 png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
nuclear@0 2710 png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
nuclear@0 2711 png_uint_16pp gamma_16_to_1, int gamma_shift
nuclear@0 2712 #endif
nuclear@0 2713 )
nuclear@0 2714 {
nuclear@0 2715 png_bytep sp, dp;
nuclear@0 2716 png_uint_32 i;
nuclear@0 2717 png_uint_32 row_width=row_info->width;
nuclear@0 2718 int shift;
nuclear@0 2719
nuclear@0 2720 png_debug(1, "in png_do_background\n");
nuclear@0 2721 if (background != NULL &&
nuclear@0 2722 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 2723 row != NULL && row_info != NULL &&
nuclear@0 2724 #endif
nuclear@0 2725 (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
nuclear@0 2726 (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))
nuclear@0 2727 {
nuclear@0 2728 switch (row_info->color_type)
nuclear@0 2729 {
nuclear@0 2730 case PNG_COLOR_TYPE_GRAY:
nuclear@0 2731 {
nuclear@0 2732 switch (row_info->bit_depth)
nuclear@0 2733 {
nuclear@0 2734 case 1:
nuclear@0 2735 {
nuclear@0 2736 sp = row;
nuclear@0 2737 shift = 7;
nuclear@0 2738 for (i = 0; i < row_width; i++)
nuclear@0 2739 {
nuclear@0 2740 if ((png_uint_16)((*sp >> shift) & 0x01)
nuclear@0 2741 == trans_values->gray)
nuclear@0 2742 {
nuclear@0 2743 *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
nuclear@0 2744 *sp |= (png_byte)(background->gray << shift);
nuclear@0 2745 }
nuclear@0 2746 if (!shift)
nuclear@0 2747 {
nuclear@0 2748 shift = 7;
nuclear@0 2749 sp++;
nuclear@0 2750 }
nuclear@0 2751 else
nuclear@0 2752 shift--;
nuclear@0 2753 }
nuclear@0 2754 break;
nuclear@0 2755 }
nuclear@0 2756 case 2:
nuclear@0 2757 {
nuclear@0 2758 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2759 if (gamma_table != NULL)
nuclear@0 2760 {
nuclear@0 2761 sp = row;
nuclear@0 2762 shift = 6;
nuclear@0 2763 for (i = 0; i < row_width; i++)
nuclear@0 2764 {
nuclear@0 2765 if ((png_uint_16)((*sp >> shift) & 0x03)
nuclear@0 2766 == trans_values->gray)
nuclear@0 2767 {
nuclear@0 2768 *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
nuclear@0 2769 *sp |= (png_byte)(background->gray << shift);
nuclear@0 2770 }
nuclear@0 2771 else
nuclear@0 2772 {
nuclear@0 2773 png_byte p = (png_byte)((*sp >> shift) & 0x03);
nuclear@0 2774 png_byte g = (png_byte)((gamma_table [p | (p << 2) |
nuclear@0 2775 (p << 4) | (p << 6)] >> 6) & 0x03);
nuclear@0 2776 *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
nuclear@0 2777 *sp |= (png_byte)(g << shift);
nuclear@0 2778 }
nuclear@0 2779 if (!shift)
nuclear@0 2780 {
nuclear@0 2781 shift = 6;
nuclear@0 2782 sp++;
nuclear@0 2783 }
nuclear@0 2784 else
nuclear@0 2785 shift -= 2;
nuclear@0 2786 }
nuclear@0 2787 }
nuclear@0 2788 else
nuclear@0 2789 #endif
nuclear@0 2790 {
nuclear@0 2791 sp = row;
nuclear@0 2792 shift = 6;
nuclear@0 2793 for (i = 0; i < row_width; i++)
nuclear@0 2794 {
nuclear@0 2795 if ((png_uint_16)((*sp >> shift) & 0x03)
nuclear@0 2796 == trans_values->gray)
nuclear@0 2797 {
nuclear@0 2798 *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
nuclear@0 2799 *sp |= (png_byte)(background->gray << shift);
nuclear@0 2800 }
nuclear@0 2801 if (!shift)
nuclear@0 2802 {
nuclear@0 2803 shift = 6;
nuclear@0 2804 sp++;
nuclear@0 2805 }
nuclear@0 2806 else
nuclear@0 2807 shift -= 2;
nuclear@0 2808 }
nuclear@0 2809 }
nuclear@0 2810 break;
nuclear@0 2811 }
nuclear@0 2812 case 4:
nuclear@0 2813 {
nuclear@0 2814 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2815 if (gamma_table != NULL)
nuclear@0 2816 {
nuclear@0 2817 sp = row;
nuclear@0 2818 shift = 4;
nuclear@0 2819 for (i = 0; i < row_width; i++)
nuclear@0 2820 {
nuclear@0 2821 if ((png_uint_16)((*sp >> shift) & 0x0f)
nuclear@0 2822 == trans_values->gray)
nuclear@0 2823 {
nuclear@0 2824 *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
nuclear@0 2825 *sp |= (png_byte)(background->gray << shift);
nuclear@0 2826 }
nuclear@0 2827 else
nuclear@0 2828 {
nuclear@0 2829 png_byte p = (png_byte)((*sp >> shift) & 0x0f);
nuclear@0 2830 png_byte g = (png_byte)((gamma_table[p |
nuclear@0 2831 (p << 4)] >> 4) & 0x0f);
nuclear@0 2832 *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
nuclear@0 2833 *sp |= (png_byte)(g << shift);
nuclear@0 2834 }
nuclear@0 2835 if (!shift)
nuclear@0 2836 {
nuclear@0 2837 shift = 4;
nuclear@0 2838 sp++;
nuclear@0 2839 }
nuclear@0 2840 else
nuclear@0 2841 shift -= 4;
nuclear@0 2842 }
nuclear@0 2843 }
nuclear@0 2844 else
nuclear@0 2845 #endif
nuclear@0 2846 {
nuclear@0 2847 sp = row;
nuclear@0 2848 shift = 4;
nuclear@0 2849 for (i = 0; i < row_width; i++)
nuclear@0 2850 {
nuclear@0 2851 if ((png_uint_16)((*sp >> shift) & 0x0f)
nuclear@0 2852 == trans_values->gray)
nuclear@0 2853 {
nuclear@0 2854 *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
nuclear@0 2855 *sp |= (png_byte)(background->gray << shift);
nuclear@0 2856 }
nuclear@0 2857 if (!shift)
nuclear@0 2858 {
nuclear@0 2859 shift = 4;
nuclear@0 2860 sp++;
nuclear@0 2861 }
nuclear@0 2862 else
nuclear@0 2863 shift -= 4;
nuclear@0 2864 }
nuclear@0 2865 }
nuclear@0 2866 break;
nuclear@0 2867 }
nuclear@0 2868 case 8:
nuclear@0 2869 {
nuclear@0 2870 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2871 if (gamma_table != NULL)
nuclear@0 2872 {
nuclear@0 2873 sp = row;
nuclear@0 2874 for (i = 0; i < row_width; i++, sp++)
nuclear@0 2875 {
nuclear@0 2876 if (*sp == trans_values->gray)
nuclear@0 2877 {
nuclear@0 2878 *sp = (png_byte)background->gray;
nuclear@0 2879 }
nuclear@0 2880 else
nuclear@0 2881 {
nuclear@0 2882 *sp = gamma_table[*sp];
nuclear@0 2883 }
nuclear@0 2884 }
nuclear@0 2885 }
nuclear@0 2886 else
nuclear@0 2887 #endif
nuclear@0 2888 {
nuclear@0 2889 sp = row;
nuclear@0 2890 for (i = 0; i < row_width; i++, sp++)
nuclear@0 2891 {
nuclear@0 2892 if (*sp == trans_values->gray)
nuclear@0 2893 {
nuclear@0 2894 *sp = (png_byte)background->gray;
nuclear@0 2895 }
nuclear@0 2896 }
nuclear@0 2897 }
nuclear@0 2898 break;
nuclear@0 2899 }
nuclear@0 2900 case 16:
nuclear@0 2901 {
nuclear@0 2902 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2903 if (gamma_16 != NULL)
nuclear@0 2904 {
nuclear@0 2905 sp = row;
nuclear@0 2906 for (i = 0; i < row_width; i++, sp += 2)
nuclear@0 2907 {
nuclear@0 2908 png_uint_16 v;
nuclear@0 2909
nuclear@0 2910 v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
nuclear@0 2911 if (v == trans_values->gray)
nuclear@0 2912 {
nuclear@0 2913 /* background is already in screen gamma */
nuclear@0 2914 *sp = (png_byte)((background->gray >> 8) & 0xff);
nuclear@0 2915 *(sp + 1) = (png_byte)(background->gray & 0xff);
nuclear@0 2916 }
nuclear@0 2917 else
nuclear@0 2918 {
nuclear@0 2919 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 2920 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 2921 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 2922 }
nuclear@0 2923 }
nuclear@0 2924 }
nuclear@0 2925 else
nuclear@0 2926 #endif
nuclear@0 2927 {
nuclear@0 2928 sp = row;
nuclear@0 2929 for (i = 0; i < row_width; i++, sp += 2)
nuclear@0 2930 {
nuclear@0 2931 png_uint_16 v;
nuclear@0 2932
nuclear@0 2933 v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
nuclear@0 2934 if (v == trans_values->gray)
nuclear@0 2935 {
nuclear@0 2936 *sp = (png_byte)((background->gray >> 8) & 0xff);
nuclear@0 2937 *(sp + 1) = (png_byte)(background->gray & 0xff);
nuclear@0 2938 }
nuclear@0 2939 }
nuclear@0 2940 }
nuclear@0 2941 break;
nuclear@0 2942 }
nuclear@0 2943 }
nuclear@0 2944 break;
nuclear@0 2945 }
nuclear@0 2946 case PNG_COLOR_TYPE_RGB:
nuclear@0 2947 {
nuclear@0 2948 if (row_info->bit_depth == 8)
nuclear@0 2949 {
nuclear@0 2950 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2951 if (gamma_table != NULL)
nuclear@0 2952 {
nuclear@0 2953 sp = row;
nuclear@0 2954 for (i = 0; i < row_width; i++, sp += 3)
nuclear@0 2955 {
nuclear@0 2956 if (*sp == trans_values->red &&
nuclear@0 2957 *(sp + 1) == trans_values->green &&
nuclear@0 2958 *(sp + 2) == trans_values->blue)
nuclear@0 2959 {
nuclear@0 2960 *sp = (png_byte)background->red;
nuclear@0 2961 *(sp + 1) = (png_byte)background->green;
nuclear@0 2962 *(sp + 2) = (png_byte)background->blue;
nuclear@0 2963 }
nuclear@0 2964 else
nuclear@0 2965 {
nuclear@0 2966 *sp = gamma_table[*sp];
nuclear@0 2967 *(sp + 1) = gamma_table[*(sp + 1)];
nuclear@0 2968 *(sp + 2) = gamma_table[*(sp + 2)];
nuclear@0 2969 }
nuclear@0 2970 }
nuclear@0 2971 }
nuclear@0 2972 else
nuclear@0 2973 #endif
nuclear@0 2974 {
nuclear@0 2975 sp = row;
nuclear@0 2976 for (i = 0; i < row_width; i++, sp += 3)
nuclear@0 2977 {
nuclear@0 2978 if (*sp == trans_values->red &&
nuclear@0 2979 *(sp + 1) == trans_values->green &&
nuclear@0 2980 *(sp + 2) == trans_values->blue)
nuclear@0 2981 {
nuclear@0 2982 *sp = (png_byte)background->red;
nuclear@0 2983 *(sp + 1) = (png_byte)background->green;
nuclear@0 2984 *(sp + 2) = (png_byte)background->blue;
nuclear@0 2985 }
nuclear@0 2986 }
nuclear@0 2987 }
nuclear@0 2988 }
nuclear@0 2989 else /* if (row_info->bit_depth == 16) */
nuclear@0 2990 {
nuclear@0 2991 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 2992 if (gamma_16 != NULL)
nuclear@0 2993 {
nuclear@0 2994 sp = row;
nuclear@0 2995 for (i = 0; i < row_width; i++, sp += 6)
nuclear@0 2996 {
nuclear@0 2997 png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
nuclear@0 2998 png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
nuclear@0 2999 png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
nuclear@0 3000 if (r == trans_values->red && g == trans_values->green &&
nuclear@0 3001 b == trans_values->blue)
nuclear@0 3002 {
nuclear@0 3003 /* background is already in screen gamma */
nuclear@0 3004 *sp = (png_byte)((background->red >> 8) & 0xff);
nuclear@0 3005 *(sp + 1) = (png_byte)(background->red & 0xff);
nuclear@0 3006 *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
nuclear@0 3007 *(sp + 3) = (png_byte)(background->green & 0xff);
nuclear@0 3008 *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
nuclear@0 3009 *(sp + 5) = (png_byte)(background->blue & 0xff);
nuclear@0 3010 }
nuclear@0 3011 else
nuclear@0 3012 {
nuclear@0 3013 png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3014 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3015 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3016 v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
nuclear@0 3017 *(sp + 2) = (png_byte)((v >> 8) & 0xff);
nuclear@0 3018 *(sp + 3) = (png_byte)(v & 0xff);
nuclear@0 3019 v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
nuclear@0 3020 *(sp + 4) = (png_byte)((v >> 8) & 0xff);
nuclear@0 3021 *(sp + 5) = (png_byte)(v & 0xff);
nuclear@0 3022 }
nuclear@0 3023 }
nuclear@0 3024 }
nuclear@0 3025 else
nuclear@0 3026 #endif
nuclear@0 3027 {
nuclear@0 3028 sp = row;
nuclear@0 3029 for (i = 0; i < row_width; i++, sp += 6)
nuclear@0 3030 {
nuclear@0 3031 png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));
nuclear@0 3032 png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
nuclear@0 3033 png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));
nuclear@0 3034
nuclear@0 3035 if (r == trans_values->red && g == trans_values->green &&
nuclear@0 3036 b == trans_values->blue)
nuclear@0 3037 {
nuclear@0 3038 *sp = (png_byte)((background->red >> 8) & 0xff);
nuclear@0 3039 *(sp + 1) = (png_byte)(background->red & 0xff);
nuclear@0 3040 *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
nuclear@0 3041 *(sp + 3) = (png_byte)(background->green & 0xff);
nuclear@0 3042 *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);
nuclear@0 3043 *(sp + 5) = (png_byte)(background->blue & 0xff);
nuclear@0 3044 }
nuclear@0 3045 }
nuclear@0 3046 }
nuclear@0 3047 }
nuclear@0 3048 break;
nuclear@0 3049 }
nuclear@0 3050 case PNG_COLOR_TYPE_GRAY_ALPHA:
nuclear@0 3051 {
nuclear@0 3052 if (row_info->bit_depth == 8)
nuclear@0 3053 {
nuclear@0 3054 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3055 if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
nuclear@0 3056 gamma_table != NULL)
nuclear@0 3057 {
nuclear@0 3058 sp = row;
nuclear@0 3059 dp = row;
nuclear@0 3060 for (i = 0; i < row_width; i++, sp += 2, dp++)
nuclear@0 3061 {
nuclear@0 3062 png_uint_16 a = *(sp + 1);
nuclear@0 3063
nuclear@0 3064 if (a == 0xff)
nuclear@0 3065 {
nuclear@0 3066 *dp = gamma_table[*sp];
nuclear@0 3067 }
nuclear@0 3068 else if (a == 0)
nuclear@0 3069 {
nuclear@0 3070 /* background is already in screen gamma */
nuclear@0 3071 *dp = (png_byte)background->gray;
nuclear@0 3072 }
nuclear@0 3073 else
nuclear@0 3074 {
nuclear@0 3075 png_byte v, w;
nuclear@0 3076
nuclear@0 3077 v = gamma_to_1[*sp];
nuclear@0 3078 png_composite(w, v, a, background_1->gray);
nuclear@0 3079 *dp = gamma_from_1[w];
nuclear@0 3080 }
nuclear@0 3081 }
nuclear@0 3082 }
nuclear@0 3083 else
nuclear@0 3084 #endif
nuclear@0 3085 {
nuclear@0 3086 sp = row;
nuclear@0 3087 dp = row;
nuclear@0 3088 for (i = 0; i < row_width; i++, sp += 2, dp++)
nuclear@0 3089 {
nuclear@0 3090 png_byte a = *(sp + 1);
nuclear@0 3091
nuclear@0 3092 if (a == 0xff)
nuclear@0 3093 {
nuclear@0 3094 *dp = *sp;
nuclear@0 3095 }
nuclear@0 3096 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3097 else if (a == 0)
nuclear@0 3098 {
nuclear@0 3099 *dp = (png_byte)background->gray;
nuclear@0 3100 }
nuclear@0 3101 else
nuclear@0 3102 {
nuclear@0 3103 png_composite(*dp, *sp, a, background_1->gray);
nuclear@0 3104 }
nuclear@0 3105 #else
nuclear@0 3106 *dp = (png_byte)background->gray;
nuclear@0 3107 #endif
nuclear@0 3108 }
nuclear@0 3109 }
nuclear@0 3110 }
nuclear@0 3111 else /* if (png_ptr->bit_depth == 16) */
nuclear@0 3112 {
nuclear@0 3113 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3114 if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
nuclear@0 3115 gamma_16_to_1 != NULL)
nuclear@0 3116 {
nuclear@0 3117 sp = row;
nuclear@0 3118 dp = row;
nuclear@0 3119 for (i = 0; i < row_width; i++, sp += 4, dp += 2)
nuclear@0 3120 {
nuclear@0 3121 png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
nuclear@0 3122
nuclear@0 3123 if (a == (png_uint_16)0xffff)
nuclear@0 3124 {
nuclear@0 3125 png_uint_16 v;
nuclear@0 3126
nuclear@0 3127 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3128 *dp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3129 *(dp + 1) = (png_byte)(v & 0xff);
nuclear@0 3130 }
nuclear@0 3131 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3132 else if (a == 0)
nuclear@0 3133 #else
nuclear@0 3134 else
nuclear@0 3135 #endif
nuclear@0 3136 {
nuclear@0 3137 /* background is already in screen gamma */
nuclear@0 3138 *dp = (png_byte)((background->gray >> 8) & 0xff);
nuclear@0 3139 *(dp + 1) = (png_byte)(background->gray & 0xff);
nuclear@0 3140 }
nuclear@0 3141 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3142 else
nuclear@0 3143 {
nuclear@0 3144 png_uint_16 g, v, w;
nuclear@0 3145
nuclear@0 3146 g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3147 png_composite_16(v, g, a, background_1->gray);
nuclear@0 3148 w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];
nuclear@0 3149 *dp = (png_byte)((w >> 8) & 0xff);
nuclear@0 3150 *(dp + 1) = (png_byte)(w & 0xff);
nuclear@0 3151 }
nuclear@0 3152 #endif
nuclear@0 3153 }
nuclear@0 3154 }
nuclear@0 3155 else
nuclear@0 3156 #endif
nuclear@0 3157 {
nuclear@0 3158 sp = row;
nuclear@0 3159 dp = row;
nuclear@0 3160 for (i = 0; i < row_width; i++, sp += 4, dp += 2)
nuclear@0 3161 {
nuclear@0 3162 png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
nuclear@0 3163 if (a == (png_uint_16)0xffff)
nuclear@0 3164 {
nuclear@0 3165 png_memcpy(dp, sp, 2);
nuclear@0 3166 }
nuclear@0 3167 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3168 else if (a == 0)
nuclear@0 3169 #else
nuclear@0 3170 else
nuclear@0 3171 #endif
nuclear@0 3172 {
nuclear@0 3173 *dp = (png_byte)((background->gray >> 8) & 0xff);
nuclear@0 3174 *(dp + 1) = (png_byte)(background->gray & 0xff);
nuclear@0 3175 }
nuclear@0 3176 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3177 else
nuclear@0 3178 {
nuclear@0 3179 png_uint_16 g, v;
nuclear@0 3180
nuclear@0 3181 g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
nuclear@0 3182 png_composite_16(v, g, a, background_1->gray);
nuclear@0 3183 *dp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3184 *(dp + 1) = (png_byte)(v & 0xff);
nuclear@0 3185 }
nuclear@0 3186 #endif
nuclear@0 3187 }
nuclear@0 3188 }
nuclear@0 3189 }
nuclear@0 3190 break;
nuclear@0 3191 }
nuclear@0 3192 case PNG_COLOR_TYPE_RGB_ALPHA:
nuclear@0 3193 {
nuclear@0 3194 if (row_info->bit_depth == 8)
nuclear@0 3195 {
nuclear@0 3196 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3197 if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
nuclear@0 3198 gamma_table != NULL)
nuclear@0 3199 {
nuclear@0 3200 sp = row;
nuclear@0 3201 dp = row;
nuclear@0 3202 for (i = 0; i < row_width; i++, sp += 4, dp += 3)
nuclear@0 3203 {
nuclear@0 3204 png_byte a = *(sp + 3);
nuclear@0 3205
nuclear@0 3206 if (a == 0xff)
nuclear@0 3207 {
nuclear@0 3208 *dp = gamma_table[*sp];
nuclear@0 3209 *(dp + 1) = gamma_table[*(sp + 1)];
nuclear@0 3210 *(dp + 2) = gamma_table[*(sp + 2)];
nuclear@0 3211 }
nuclear@0 3212 else if (a == 0)
nuclear@0 3213 {
nuclear@0 3214 /* background is already in screen gamma */
nuclear@0 3215 *dp = (png_byte)background->red;
nuclear@0 3216 *(dp + 1) = (png_byte)background->green;
nuclear@0 3217 *(dp + 2) = (png_byte)background->blue;
nuclear@0 3218 }
nuclear@0 3219 else
nuclear@0 3220 {
nuclear@0 3221 png_byte v, w;
nuclear@0 3222
nuclear@0 3223 v = gamma_to_1[*sp];
nuclear@0 3224 png_composite(w, v, a, background_1->red);
nuclear@0 3225 *dp = gamma_from_1[w];
nuclear@0 3226 v = gamma_to_1[*(sp + 1)];
nuclear@0 3227 png_composite(w, v, a, background_1->green);
nuclear@0 3228 *(dp + 1) = gamma_from_1[w];
nuclear@0 3229 v = gamma_to_1[*(sp + 2)];
nuclear@0 3230 png_composite(w, v, a, background_1->blue);
nuclear@0 3231 *(dp + 2) = gamma_from_1[w];
nuclear@0 3232 }
nuclear@0 3233 }
nuclear@0 3234 }
nuclear@0 3235 else
nuclear@0 3236 #endif
nuclear@0 3237 {
nuclear@0 3238 sp = row;
nuclear@0 3239 dp = row;
nuclear@0 3240 for (i = 0; i < row_width; i++, sp += 4, dp += 3)
nuclear@0 3241 {
nuclear@0 3242 png_byte a = *(sp + 3);
nuclear@0 3243
nuclear@0 3244 if (a == 0xff)
nuclear@0 3245 {
nuclear@0 3246 *dp = *sp;
nuclear@0 3247 *(dp + 1) = *(sp + 1);
nuclear@0 3248 *(dp + 2) = *(sp + 2);
nuclear@0 3249 }
nuclear@0 3250 else if (a == 0)
nuclear@0 3251 {
nuclear@0 3252 *dp = (png_byte)background->red;
nuclear@0 3253 *(dp + 1) = (png_byte)background->green;
nuclear@0 3254 *(dp + 2) = (png_byte)background->blue;
nuclear@0 3255 }
nuclear@0 3256 else
nuclear@0 3257 {
nuclear@0 3258 png_composite(*dp, *sp, a, background->red);
nuclear@0 3259 png_composite(*(dp + 1), *(sp + 1), a,
nuclear@0 3260 background->green);
nuclear@0 3261 png_composite(*(dp + 2), *(sp + 2), a,
nuclear@0 3262 background->blue);
nuclear@0 3263 }
nuclear@0 3264 }
nuclear@0 3265 }
nuclear@0 3266 }
nuclear@0 3267 else /* if (row_info->bit_depth == 16) */
nuclear@0 3268 {
nuclear@0 3269 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3270 if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
nuclear@0 3271 gamma_16_to_1 != NULL)
nuclear@0 3272 {
nuclear@0 3273 sp = row;
nuclear@0 3274 dp = row;
nuclear@0 3275 for (i = 0; i < row_width; i++, sp += 8, dp += 6)
nuclear@0 3276 {
nuclear@0 3277 png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
nuclear@0 3278 << 8) + (png_uint_16)(*(sp + 7)));
nuclear@0 3279 if (a == (png_uint_16)0xffff)
nuclear@0 3280 {
nuclear@0 3281 png_uint_16 v;
nuclear@0 3282
nuclear@0 3283 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3284 *dp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3285 *(dp + 1) = (png_byte)(v & 0xff);
nuclear@0 3286 v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
nuclear@0 3287 *(dp + 2) = (png_byte)((v >> 8) & 0xff);
nuclear@0 3288 *(dp + 3) = (png_byte)(v & 0xff);
nuclear@0 3289 v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
nuclear@0 3290 *(dp + 4) = (png_byte)((v >> 8) & 0xff);
nuclear@0 3291 *(dp + 5) = (png_byte)(v & 0xff);
nuclear@0 3292 }
nuclear@0 3293 else if (a == 0)
nuclear@0 3294 {
nuclear@0 3295 /* background is already in screen gamma */
nuclear@0 3296 *dp = (png_byte)((background->red >> 8) & 0xff);
nuclear@0 3297 *(dp + 1) = (png_byte)(background->red & 0xff);
nuclear@0 3298 *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
nuclear@0 3299 *(dp + 3) = (png_byte)(background->green & 0xff);
nuclear@0 3300 *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
nuclear@0 3301 *(dp + 5) = (png_byte)(background->blue & 0xff);
nuclear@0 3302 }
nuclear@0 3303 else
nuclear@0 3304 {
nuclear@0 3305 png_uint_16 v, w, x;
nuclear@0 3306
nuclear@0 3307 v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3308 png_composite_16(w, v, a, background_1->red);
nuclear@0 3309 x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
nuclear@0 3310 *dp = (png_byte)((x >> 8) & 0xff);
nuclear@0 3311 *(dp + 1) = (png_byte)(x & 0xff);
nuclear@0 3312 v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
nuclear@0 3313 png_composite_16(w, v, a, background_1->green);
nuclear@0 3314 x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];
nuclear@0 3315 *(dp + 2) = (png_byte)((x >> 8) & 0xff);
nuclear@0 3316 *(dp + 3) = (png_byte)(x & 0xff);
nuclear@0 3317 v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
nuclear@0 3318 png_composite_16(w, v, a, background_1->blue);
nuclear@0 3319 x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];
nuclear@0 3320 *(dp + 4) = (png_byte)((x >> 8) & 0xff);
nuclear@0 3321 *(dp + 5) = (png_byte)(x & 0xff);
nuclear@0 3322 }
nuclear@0 3323 }
nuclear@0 3324 }
nuclear@0 3325 else
nuclear@0 3326 #endif
nuclear@0 3327 {
nuclear@0 3328 sp = row;
nuclear@0 3329 dp = row;
nuclear@0 3330 for (i = 0; i < row_width; i++, sp += 8, dp += 6)
nuclear@0 3331 {
nuclear@0 3332 png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
nuclear@0 3333 << 8) + (png_uint_16)(*(sp + 7)));
nuclear@0 3334 if (a == (png_uint_16)0xffff)
nuclear@0 3335 {
nuclear@0 3336 png_memcpy(dp, sp, 6);
nuclear@0 3337 }
nuclear@0 3338 else if (a == 0)
nuclear@0 3339 {
nuclear@0 3340 *dp = (png_byte)((background->red >> 8) & 0xff);
nuclear@0 3341 *(dp + 1) = (png_byte)(background->red & 0xff);
nuclear@0 3342 *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);
nuclear@0 3343 *(dp + 3) = (png_byte)(background->green & 0xff);
nuclear@0 3344 *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);
nuclear@0 3345 *(dp + 5) = (png_byte)(background->blue & 0xff);
nuclear@0 3346 }
nuclear@0 3347 else
nuclear@0 3348 {
nuclear@0 3349 png_uint_16 v;
nuclear@0 3350
nuclear@0 3351 png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
nuclear@0 3352 png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
nuclear@0 3353 + *(sp + 3));
nuclear@0 3354 png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
nuclear@0 3355 + *(sp + 5));
nuclear@0 3356
nuclear@0 3357 png_composite_16(v, r, a, background->red);
nuclear@0 3358 *dp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3359 *(dp + 1) = (png_byte)(v & 0xff);
nuclear@0 3360 png_composite_16(v, g, a, background->green);
nuclear@0 3361 *(dp + 2) = (png_byte)((v >> 8) & 0xff);
nuclear@0 3362 *(dp + 3) = (png_byte)(v & 0xff);
nuclear@0 3363 png_composite_16(v, b, a, background->blue);
nuclear@0 3364 *(dp + 4) = (png_byte)((v >> 8) & 0xff);
nuclear@0 3365 *(dp + 5) = (png_byte)(v & 0xff);
nuclear@0 3366 }
nuclear@0 3367 }
nuclear@0 3368 }
nuclear@0 3369 }
nuclear@0 3370 break;
nuclear@0 3371 }
nuclear@0 3372 }
nuclear@0 3373
nuclear@0 3374 if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
nuclear@0 3375 {
nuclear@0 3376 row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
nuclear@0 3377 row_info->channels--;
nuclear@0 3378 row_info->pixel_depth = (png_byte)(row_info->channels *
nuclear@0 3379 row_info->bit_depth);
nuclear@0 3380 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
nuclear@0 3381 }
nuclear@0 3382 }
nuclear@0 3383 }
nuclear@0 3384 #endif
nuclear@0 3385
nuclear@0 3386 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 3387 /* Gamma correct the image, avoiding the alpha channel. Make sure
nuclear@0 3388 * you do this after you deal with the transparency issue on grayscale
nuclear@0 3389 * or RGB images. If your bit depth is 8, use gamma_table, if it
nuclear@0 3390 * is 16, use gamma_16_table and gamma_shift. Build these with
nuclear@0 3391 * build_gamma_table().
nuclear@0 3392 */
nuclear@0 3393 void /* PRIVATE */
nuclear@0 3394 png_do_gamma(png_row_infop row_info, png_bytep row,
nuclear@0 3395 png_bytep gamma_table, png_uint_16pp gamma_16_table,
nuclear@0 3396 int gamma_shift)
nuclear@0 3397 {
nuclear@0 3398 png_bytep sp;
nuclear@0 3399 png_uint_32 i;
nuclear@0 3400 png_uint_32 row_width=row_info->width;
nuclear@0 3401
nuclear@0 3402 png_debug(1, "in png_do_gamma\n");
nuclear@0 3403 if (
nuclear@0 3404 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 3405 row != NULL && row_info != NULL &&
nuclear@0 3406 #endif
nuclear@0 3407 ((row_info->bit_depth <= 8 && gamma_table != NULL) ||
nuclear@0 3408 (row_info->bit_depth == 16 && gamma_16_table != NULL)))
nuclear@0 3409 {
nuclear@0 3410 switch (row_info->color_type)
nuclear@0 3411 {
nuclear@0 3412 case PNG_COLOR_TYPE_RGB:
nuclear@0 3413 {
nuclear@0 3414 if (row_info->bit_depth == 8)
nuclear@0 3415 {
nuclear@0 3416 sp = row;
nuclear@0 3417 for (i = 0; i < row_width; i++)
nuclear@0 3418 {
nuclear@0 3419 *sp = gamma_table[*sp];
nuclear@0 3420 sp++;
nuclear@0 3421 *sp = gamma_table[*sp];
nuclear@0 3422 sp++;
nuclear@0 3423 *sp = gamma_table[*sp];
nuclear@0 3424 sp++;
nuclear@0 3425 }
nuclear@0 3426 }
nuclear@0 3427 else /* if (row_info->bit_depth == 16) */
nuclear@0 3428 {
nuclear@0 3429 sp = row;
nuclear@0 3430 for (i = 0; i < row_width; i++)
nuclear@0 3431 {
nuclear@0 3432 png_uint_16 v;
nuclear@0 3433
nuclear@0 3434 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3435 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3436 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3437 sp += 2;
nuclear@0 3438 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3439 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3440 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3441 sp += 2;
nuclear@0 3442 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3443 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3444 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3445 sp += 2;
nuclear@0 3446 }
nuclear@0 3447 }
nuclear@0 3448 break;
nuclear@0 3449 }
nuclear@0 3450 case PNG_COLOR_TYPE_RGB_ALPHA:
nuclear@0 3451 {
nuclear@0 3452 if (row_info->bit_depth == 8)
nuclear@0 3453 {
nuclear@0 3454 sp = row;
nuclear@0 3455 for (i = 0; i < row_width; i++)
nuclear@0 3456 {
nuclear@0 3457 *sp = gamma_table[*sp];
nuclear@0 3458 sp++;
nuclear@0 3459 *sp = gamma_table[*sp];
nuclear@0 3460 sp++;
nuclear@0 3461 *sp = gamma_table[*sp];
nuclear@0 3462 sp++;
nuclear@0 3463 sp++;
nuclear@0 3464 }
nuclear@0 3465 }
nuclear@0 3466 else /* if (row_info->bit_depth == 16) */
nuclear@0 3467 {
nuclear@0 3468 sp = row;
nuclear@0 3469 for (i = 0; i < row_width; i++)
nuclear@0 3470 {
nuclear@0 3471 png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3472 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3473 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3474 sp += 2;
nuclear@0 3475 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3476 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3477 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3478 sp += 2;
nuclear@0 3479 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3480 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3481 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3482 sp += 4;
nuclear@0 3483 }
nuclear@0 3484 }
nuclear@0 3485 break;
nuclear@0 3486 }
nuclear@0 3487 case PNG_COLOR_TYPE_GRAY_ALPHA:
nuclear@0 3488 {
nuclear@0 3489 if (row_info->bit_depth == 8)
nuclear@0 3490 {
nuclear@0 3491 sp = row;
nuclear@0 3492 for (i = 0; i < row_width; i++)
nuclear@0 3493 {
nuclear@0 3494 *sp = gamma_table[*sp];
nuclear@0 3495 sp += 2;
nuclear@0 3496 }
nuclear@0 3497 }
nuclear@0 3498 else /* if (row_info->bit_depth == 16) */
nuclear@0 3499 {
nuclear@0 3500 sp = row;
nuclear@0 3501 for (i = 0; i < row_width; i++)
nuclear@0 3502 {
nuclear@0 3503 png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3504 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3505 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3506 sp += 4;
nuclear@0 3507 }
nuclear@0 3508 }
nuclear@0 3509 break;
nuclear@0 3510 }
nuclear@0 3511 case PNG_COLOR_TYPE_GRAY:
nuclear@0 3512 {
nuclear@0 3513 if (row_info->bit_depth == 2)
nuclear@0 3514 {
nuclear@0 3515 sp = row;
nuclear@0 3516 for (i = 0; i < row_width; i += 4)
nuclear@0 3517 {
nuclear@0 3518 int a = *sp & 0xc0;
nuclear@0 3519 int b = *sp & 0x30;
nuclear@0 3520 int c = *sp & 0x0c;
nuclear@0 3521 int d = *sp & 0x03;
nuclear@0 3522
nuclear@0 3523 *sp = (png_byte)(
nuclear@0 3524 ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)|
nuclear@0 3525 ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|
nuclear@0 3526 ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|
nuclear@0 3527 ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));
nuclear@0 3528 sp++;
nuclear@0 3529 }
nuclear@0 3530 }
nuclear@0 3531 if (row_info->bit_depth == 4)
nuclear@0 3532 {
nuclear@0 3533 sp = row;
nuclear@0 3534 for (i = 0; i < row_width; i += 2)
nuclear@0 3535 {
nuclear@0 3536 int msb = *sp & 0xf0;
nuclear@0 3537 int lsb = *sp & 0x0f;
nuclear@0 3538
nuclear@0 3539 *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)
nuclear@0 3540 | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));
nuclear@0 3541 sp++;
nuclear@0 3542 }
nuclear@0 3543 }
nuclear@0 3544 else if (row_info->bit_depth == 8)
nuclear@0 3545 {
nuclear@0 3546 sp = row;
nuclear@0 3547 for (i = 0; i < row_width; i++)
nuclear@0 3548 {
nuclear@0 3549 *sp = gamma_table[*sp];
nuclear@0 3550 sp++;
nuclear@0 3551 }
nuclear@0 3552 }
nuclear@0 3553 else if (row_info->bit_depth == 16)
nuclear@0 3554 {
nuclear@0 3555 sp = row;
nuclear@0 3556 for (i = 0; i < row_width; i++)
nuclear@0 3557 {
nuclear@0 3558 png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];
nuclear@0 3559 *sp = (png_byte)((v >> 8) & 0xff);
nuclear@0 3560 *(sp + 1) = (png_byte)(v & 0xff);
nuclear@0 3561 sp += 2;
nuclear@0 3562 }
nuclear@0 3563 }
nuclear@0 3564 break;
nuclear@0 3565 }
nuclear@0 3566 }
nuclear@0 3567 }
nuclear@0 3568 }
nuclear@0 3569 #endif
nuclear@0 3570
nuclear@0 3571 #if defined(PNG_READ_EXPAND_SUPPORTED)
nuclear@0 3572 /* Expands a palette row to an RGB or RGBA row depending
nuclear@0 3573 * upon whether you supply trans and num_trans.
nuclear@0 3574 */
nuclear@0 3575 void /* PRIVATE */
nuclear@0 3576 png_do_expand_palette(png_row_infop row_info, png_bytep row,
nuclear@0 3577 png_colorp palette, png_bytep trans, int num_trans)
nuclear@0 3578 {
nuclear@0 3579 int shift, value;
nuclear@0 3580 png_bytep sp, dp;
nuclear@0 3581 png_uint_32 i;
nuclear@0 3582 png_uint_32 row_width=row_info->width;
nuclear@0 3583
nuclear@0 3584 png_debug(1, "in png_do_expand_palette\n");
nuclear@0 3585 if (
nuclear@0 3586 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 3587 row != NULL && row_info != NULL &&
nuclear@0 3588 #endif
nuclear@0 3589 row_info->color_type == PNG_COLOR_TYPE_PALETTE)
nuclear@0 3590 {
nuclear@0 3591 if (row_info->bit_depth < 8)
nuclear@0 3592 {
nuclear@0 3593 switch (row_info->bit_depth)
nuclear@0 3594 {
nuclear@0 3595 case 1:
nuclear@0 3596 {
nuclear@0 3597 sp = row + (png_size_t)((row_width - 1) >> 3);
nuclear@0 3598 dp = row + (png_size_t)row_width - 1;
nuclear@0 3599 shift = 7 - (int)((row_width + 7) & 0x07);
nuclear@0 3600 for (i = 0; i < row_width; i++)
nuclear@0 3601 {
nuclear@0 3602 if ((*sp >> shift) & 0x01)
nuclear@0 3603 *dp = 1;
nuclear@0 3604 else
nuclear@0 3605 *dp = 0;
nuclear@0 3606 if (shift == 7)
nuclear@0 3607 {
nuclear@0 3608 shift = 0;
nuclear@0 3609 sp--;
nuclear@0 3610 }
nuclear@0 3611 else
nuclear@0 3612 shift++;
nuclear@0 3613
nuclear@0 3614 dp--;
nuclear@0 3615 }
nuclear@0 3616 break;
nuclear@0 3617 }
nuclear@0 3618 case 2:
nuclear@0 3619 {
nuclear@0 3620 sp = row + (png_size_t)((row_width - 1) >> 2);
nuclear@0 3621 dp = row + (png_size_t)row_width - 1;
nuclear@0 3622 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
nuclear@0 3623 for (i = 0; i < row_width; i++)
nuclear@0 3624 {
nuclear@0 3625 value = (*sp >> shift) & 0x03;
nuclear@0 3626 *dp = (png_byte)value;
nuclear@0 3627 if (shift == 6)
nuclear@0 3628 {
nuclear@0 3629 shift = 0;
nuclear@0 3630 sp--;
nuclear@0 3631 }
nuclear@0 3632 else
nuclear@0 3633 shift += 2;
nuclear@0 3634
nuclear@0 3635 dp--;
nuclear@0 3636 }
nuclear@0 3637 break;
nuclear@0 3638 }
nuclear@0 3639 case 4:
nuclear@0 3640 {
nuclear@0 3641 sp = row + (png_size_t)((row_width - 1) >> 1);
nuclear@0 3642 dp = row + (png_size_t)row_width - 1;
nuclear@0 3643 shift = (int)((row_width & 0x01) << 2);
nuclear@0 3644 for (i = 0; i < row_width; i++)
nuclear@0 3645 {
nuclear@0 3646 value = (*sp >> shift) & 0x0f;
nuclear@0 3647 *dp = (png_byte)value;
nuclear@0 3648 if (shift == 4)
nuclear@0 3649 {
nuclear@0 3650 shift = 0;
nuclear@0 3651 sp--;
nuclear@0 3652 }
nuclear@0 3653 else
nuclear@0 3654 shift += 4;
nuclear@0 3655
nuclear@0 3656 dp--;
nuclear@0 3657 }
nuclear@0 3658 break;
nuclear@0 3659 }
nuclear@0 3660 }
nuclear@0 3661 row_info->bit_depth = 8;
nuclear@0 3662 row_info->pixel_depth = 8;
nuclear@0 3663 row_info->rowbytes = row_width;
nuclear@0 3664 }
nuclear@0 3665 switch (row_info->bit_depth)
nuclear@0 3666 {
nuclear@0 3667 case 8:
nuclear@0 3668 {
nuclear@0 3669 if (trans != NULL)
nuclear@0 3670 {
nuclear@0 3671 sp = row + (png_size_t)row_width - 1;
nuclear@0 3672 dp = row + (png_size_t)(row_width << 2) - 1;
nuclear@0 3673
nuclear@0 3674 for (i = 0; i < row_width; i++)
nuclear@0 3675 {
nuclear@0 3676 if ((int)(*sp) >= num_trans)
nuclear@0 3677 *dp-- = 0xff;
nuclear@0 3678 else
nuclear@0 3679 *dp-- = trans[*sp];
nuclear@0 3680 *dp-- = palette[*sp].blue;
nuclear@0 3681 *dp-- = palette[*sp].green;
nuclear@0 3682 *dp-- = palette[*sp].red;
nuclear@0 3683 sp--;
nuclear@0 3684 }
nuclear@0 3685 row_info->bit_depth = 8;
nuclear@0 3686 row_info->pixel_depth = 32;
nuclear@0 3687 row_info->rowbytes = row_width * 4;
nuclear@0 3688 row_info->color_type = 6;
nuclear@0 3689 row_info->channels = 4;
nuclear@0 3690 }
nuclear@0 3691 else
nuclear@0 3692 {
nuclear@0 3693 sp = row + (png_size_t)row_width - 1;
nuclear@0 3694 dp = row + (png_size_t)(row_width * 3) - 1;
nuclear@0 3695
nuclear@0 3696 for (i = 0; i < row_width; i++)
nuclear@0 3697 {
nuclear@0 3698 *dp-- = palette[*sp].blue;
nuclear@0 3699 *dp-- = palette[*sp].green;
nuclear@0 3700 *dp-- = palette[*sp].red;
nuclear@0 3701 sp--;
nuclear@0 3702 }
nuclear@0 3703 row_info->bit_depth = 8;
nuclear@0 3704 row_info->pixel_depth = 24;
nuclear@0 3705 row_info->rowbytes = row_width * 3;
nuclear@0 3706 row_info->color_type = 2;
nuclear@0 3707 row_info->channels = 3;
nuclear@0 3708 }
nuclear@0 3709 break;
nuclear@0 3710 }
nuclear@0 3711 }
nuclear@0 3712 }
nuclear@0 3713 }
nuclear@0 3714
nuclear@0 3715 /* If the bit depth < 8, it is expanded to 8. Also, if the already
nuclear@0 3716 * expanded transparency value is supplied, an alpha channel is built.
nuclear@0 3717 */
nuclear@0 3718 void /* PRIVATE */
nuclear@0 3719 png_do_expand(png_row_infop row_info, png_bytep row,
nuclear@0 3720 png_color_16p trans_value)
nuclear@0 3721 {
nuclear@0 3722 int shift, value;
nuclear@0 3723 png_bytep sp, dp;
nuclear@0 3724 png_uint_32 i;
nuclear@0 3725 png_uint_32 row_width=row_info->width;
nuclear@0 3726
nuclear@0 3727 png_debug(1, "in png_do_expand\n");
nuclear@0 3728 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 3729 if (row != NULL && row_info != NULL)
nuclear@0 3730 #endif
nuclear@0 3731 {
nuclear@0 3732 if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
nuclear@0 3733 {
nuclear@0 3734 png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);
nuclear@0 3735
nuclear@0 3736 if (row_info->bit_depth < 8)
nuclear@0 3737 {
nuclear@0 3738 switch (row_info->bit_depth)
nuclear@0 3739 {
nuclear@0 3740 case 1:
nuclear@0 3741 {
nuclear@0 3742 gray = (png_uint_16)((gray&0x01)*0xff);
nuclear@0 3743 sp = row + (png_size_t)((row_width - 1) >> 3);
nuclear@0 3744 dp = row + (png_size_t)row_width - 1;
nuclear@0 3745 shift = 7 - (int)((row_width + 7) & 0x07);
nuclear@0 3746 for (i = 0; i < row_width; i++)
nuclear@0 3747 {
nuclear@0 3748 if ((*sp >> shift) & 0x01)
nuclear@0 3749 *dp = 0xff;
nuclear@0 3750 else
nuclear@0 3751 *dp = 0;
nuclear@0 3752 if (shift == 7)
nuclear@0 3753 {
nuclear@0 3754 shift = 0;
nuclear@0 3755 sp--;
nuclear@0 3756 }
nuclear@0 3757 else
nuclear@0 3758 shift++;
nuclear@0 3759
nuclear@0 3760 dp--;
nuclear@0 3761 }
nuclear@0 3762 break;
nuclear@0 3763 }
nuclear@0 3764 case 2:
nuclear@0 3765 {
nuclear@0 3766 gray = (png_uint_16)((gray&0x03)*0x55);
nuclear@0 3767 sp = row + (png_size_t)((row_width - 1) >> 2);
nuclear@0 3768 dp = row + (png_size_t)row_width - 1;
nuclear@0 3769 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
nuclear@0 3770 for (i = 0; i < row_width; i++)
nuclear@0 3771 {
nuclear@0 3772 value = (*sp >> shift) & 0x03;
nuclear@0 3773 *dp = (png_byte)(value | (value << 2) | (value << 4) |
nuclear@0 3774 (value << 6));
nuclear@0 3775 if (shift == 6)
nuclear@0 3776 {
nuclear@0 3777 shift = 0;
nuclear@0 3778 sp--;
nuclear@0 3779 }
nuclear@0 3780 else
nuclear@0 3781 shift += 2;
nuclear@0 3782
nuclear@0 3783 dp--;
nuclear@0 3784 }
nuclear@0 3785 break;
nuclear@0 3786 }
nuclear@0 3787 case 4:
nuclear@0 3788 {
nuclear@0 3789 gray = (png_uint_16)((gray&0x0f)*0x11);
nuclear@0 3790 sp = row + (png_size_t)((row_width - 1) >> 1);
nuclear@0 3791 dp = row + (png_size_t)row_width - 1;
nuclear@0 3792 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
nuclear@0 3793 for (i = 0; i < row_width; i++)
nuclear@0 3794 {
nuclear@0 3795 value = (*sp >> shift) & 0x0f;
nuclear@0 3796 *dp = (png_byte)(value | (value << 4));
nuclear@0 3797 if (shift == 4)
nuclear@0 3798 {
nuclear@0 3799 shift = 0;
nuclear@0 3800 sp--;
nuclear@0 3801 }
nuclear@0 3802 else
nuclear@0 3803 shift = 4;
nuclear@0 3804
nuclear@0 3805 dp--;
nuclear@0 3806 }
nuclear@0 3807 break;
nuclear@0 3808 }
nuclear@0 3809 }
nuclear@0 3810 row_info->bit_depth = 8;
nuclear@0 3811 row_info->pixel_depth = 8;
nuclear@0 3812 row_info->rowbytes = row_width;
nuclear@0 3813 }
nuclear@0 3814
nuclear@0 3815 if (trans_value != NULL)
nuclear@0 3816 {
nuclear@0 3817 if (row_info->bit_depth == 8)
nuclear@0 3818 {
nuclear@0 3819 gray = gray & 0xff;
nuclear@0 3820 sp = row + (png_size_t)row_width - 1;
nuclear@0 3821 dp = row + (png_size_t)(row_width << 1) - 1;
nuclear@0 3822 for (i = 0; i < row_width; i++)
nuclear@0 3823 {
nuclear@0 3824 if (*sp == gray)
nuclear@0 3825 *dp-- = 0;
nuclear@0 3826 else
nuclear@0 3827 *dp-- = 0xff;
nuclear@0 3828 *dp-- = *sp--;
nuclear@0 3829 }
nuclear@0 3830 }
nuclear@0 3831 else if (row_info->bit_depth == 16)
nuclear@0 3832 {
nuclear@0 3833 png_byte gray_high = (gray >> 8) & 0xff;
nuclear@0 3834 png_byte gray_low = gray & 0xff;
nuclear@0 3835 sp = row + row_info->rowbytes - 1;
nuclear@0 3836 dp = row + (row_info->rowbytes << 1) - 1;
nuclear@0 3837 for (i = 0; i < row_width; i++)
nuclear@0 3838 {
nuclear@0 3839 if (*(sp - 1) == gray_high && *(sp) == gray_low)
nuclear@0 3840 {
nuclear@0 3841 *dp-- = 0;
nuclear@0 3842 *dp-- = 0;
nuclear@0 3843 }
nuclear@0 3844 else
nuclear@0 3845 {
nuclear@0 3846 *dp-- = 0xff;
nuclear@0 3847 *dp-- = 0xff;
nuclear@0 3848 }
nuclear@0 3849 *dp-- = *sp--;
nuclear@0 3850 *dp-- = *sp--;
nuclear@0 3851 }
nuclear@0 3852 }
nuclear@0 3853 row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
nuclear@0 3854 row_info->channels = 2;
nuclear@0 3855 row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
nuclear@0 3856 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
nuclear@0 3857 row_width);
nuclear@0 3858 }
nuclear@0 3859 }
nuclear@0 3860 else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)
nuclear@0 3861 {
nuclear@0 3862 if (row_info->bit_depth == 8)
nuclear@0 3863 {
nuclear@0 3864 png_byte red = trans_value->red & 0xff;
nuclear@0 3865 png_byte green = trans_value->green & 0xff;
nuclear@0 3866 png_byte blue = trans_value->blue & 0xff;
nuclear@0 3867 sp = row + (png_size_t)row_info->rowbytes - 1;
nuclear@0 3868 dp = row + (png_size_t)(row_width << 2) - 1;
nuclear@0 3869 for (i = 0; i < row_width; i++)
nuclear@0 3870 {
nuclear@0 3871 if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
nuclear@0 3872 *dp-- = 0;
nuclear@0 3873 else
nuclear@0 3874 *dp-- = 0xff;
nuclear@0 3875 *dp-- = *sp--;
nuclear@0 3876 *dp-- = *sp--;
nuclear@0 3877 *dp-- = *sp--;
nuclear@0 3878 }
nuclear@0 3879 }
nuclear@0 3880 else if (row_info->bit_depth == 16)
nuclear@0 3881 {
nuclear@0 3882 png_byte red_high = (trans_value->red >> 8) & 0xff;
nuclear@0 3883 png_byte green_high = (trans_value->green >> 8) & 0xff;
nuclear@0 3884 png_byte blue_high = (trans_value->blue >> 8) & 0xff;
nuclear@0 3885 png_byte red_low = trans_value->red & 0xff;
nuclear@0 3886 png_byte green_low = trans_value->green & 0xff;
nuclear@0 3887 png_byte blue_low = trans_value->blue & 0xff;
nuclear@0 3888 sp = row + row_info->rowbytes - 1;
nuclear@0 3889 dp = row + (png_size_t)(row_width << 3) - 1;
nuclear@0 3890 for (i = 0; i < row_width; i++)
nuclear@0 3891 {
nuclear@0 3892 if (*(sp - 5) == red_high &&
nuclear@0 3893 *(sp - 4) == red_low &&
nuclear@0 3894 *(sp - 3) == green_high &&
nuclear@0 3895 *(sp - 2) == green_low &&
nuclear@0 3896 *(sp - 1) == blue_high &&
nuclear@0 3897 *(sp ) == blue_low)
nuclear@0 3898 {
nuclear@0 3899 *dp-- = 0;
nuclear@0 3900 *dp-- = 0;
nuclear@0 3901 }
nuclear@0 3902 else
nuclear@0 3903 {
nuclear@0 3904 *dp-- = 0xff;
nuclear@0 3905 *dp-- = 0xff;
nuclear@0 3906 }
nuclear@0 3907 *dp-- = *sp--;
nuclear@0 3908 *dp-- = *sp--;
nuclear@0 3909 *dp-- = *sp--;
nuclear@0 3910 *dp-- = *sp--;
nuclear@0 3911 *dp-- = *sp--;
nuclear@0 3912 *dp-- = *sp--;
nuclear@0 3913 }
nuclear@0 3914 }
nuclear@0 3915 row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
nuclear@0 3916 row_info->channels = 4;
nuclear@0 3917 row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
nuclear@0 3918 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
nuclear@0 3919 }
nuclear@0 3920 }
nuclear@0 3921 }
nuclear@0 3922 #endif
nuclear@0 3923
nuclear@0 3924 #if defined(PNG_READ_DITHER_SUPPORTED)
nuclear@0 3925 void /* PRIVATE */
nuclear@0 3926 png_do_dither(png_row_infop row_info, png_bytep row,
nuclear@0 3927 png_bytep palette_lookup, png_bytep dither_lookup)
nuclear@0 3928 {
nuclear@0 3929 png_bytep sp, dp;
nuclear@0 3930 png_uint_32 i;
nuclear@0 3931 png_uint_32 row_width=row_info->width;
nuclear@0 3932
nuclear@0 3933 png_debug(1, "in png_do_dither\n");
nuclear@0 3934 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 3935 if (row != NULL && row_info != NULL)
nuclear@0 3936 #endif
nuclear@0 3937 {
nuclear@0 3938 if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
nuclear@0 3939 palette_lookup && row_info->bit_depth == 8)
nuclear@0 3940 {
nuclear@0 3941 int r, g, b, p;
nuclear@0 3942 sp = row;
nuclear@0 3943 dp = row;
nuclear@0 3944 for (i = 0; i < row_width; i++)
nuclear@0 3945 {
nuclear@0 3946 r = *sp++;
nuclear@0 3947 g = *sp++;
nuclear@0 3948 b = *sp++;
nuclear@0 3949
nuclear@0 3950 /* this looks real messy, but the compiler will reduce
nuclear@0 3951 it down to a reasonable formula. For example, with
nuclear@0 3952 5 bits per color, we get:
nuclear@0 3953 p = (((r >> 3) & 0x1f) << 10) |
nuclear@0 3954 (((g >> 3) & 0x1f) << 5) |
nuclear@0 3955 ((b >> 3) & 0x1f);
nuclear@0 3956 */
nuclear@0 3957 p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
nuclear@0 3958 ((1 << PNG_DITHER_RED_BITS) - 1)) <<
nuclear@0 3959 (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
nuclear@0 3960 (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
nuclear@0 3961 ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
nuclear@0 3962 (PNG_DITHER_BLUE_BITS)) |
nuclear@0 3963 ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
nuclear@0 3964 ((1 << PNG_DITHER_BLUE_BITS) - 1));
nuclear@0 3965
nuclear@0 3966 *dp++ = palette_lookup[p];
nuclear@0 3967 }
nuclear@0 3968 row_info->color_type = PNG_COLOR_TYPE_PALETTE;
nuclear@0 3969 row_info->channels = 1;
nuclear@0 3970 row_info->pixel_depth = row_info->bit_depth;
nuclear@0 3971 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
nuclear@0 3972 }
nuclear@0 3973 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
nuclear@0 3974 palette_lookup != NULL && row_info->bit_depth == 8)
nuclear@0 3975 {
nuclear@0 3976 int r, g, b, p;
nuclear@0 3977 sp = row;
nuclear@0 3978 dp = row;
nuclear@0 3979 for (i = 0; i < row_width; i++)
nuclear@0 3980 {
nuclear@0 3981 r = *sp++;
nuclear@0 3982 g = *sp++;
nuclear@0 3983 b = *sp++;
nuclear@0 3984 sp++;
nuclear@0 3985
nuclear@0 3986 p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
nuclear@0 3987 ((1 << PNG_DITHER_RED_BITS) - 1)) <<
nuclear@0 3988 (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
nuclear@0 3989 (((g >> (8 - PNG_DITHER_GREEN_BITS)) &
nuclear@0 3990 ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
nuclear@0 3991 (PNG_DITHER_BLUE_BITS)) |
nuclear@0 3992 ((b >> (8 - PNG_DITHER_BLUE_BITS)) &
nuclear@0 3993 ((1 << PNG_DITHER_BLUE_BITS) - 1));
nuclear@0 3994
nuclear@0 3995 *dp++ = palette_lookup[p];
nuclear@0 3996 }
nuclear@0 3997 row_info->color_type = PNG_COLOR_TYPE_PALETTE;
nuclear@0 3998 row_info->channels = 1;
nuclear@0 3999 row_info->pixel_depth = row_info->bit_depth;
nuclear@0 4000 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
nuclear@0 4001 }
nuclear@0 4002 else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
nuclear@0 4003 dither_lookup && row_info->bit_depth == 8)
nuclear@0 4004 {
nuclear@0 4005 sp = row;
nuclear@0 4006 for (i = 0; i < row_width; i++, sp++)
nuclear@0 4007 {
nuclear@0 4008 *sp = dither_lookup[*sp];
nuclear@0 4009 }
nuclear@0 4010 }
nuclear@0 4011 }
nuclear@0 4012 }
nuclear@0 4013 #endif
nuclear@0 4014
nuclear@0 4015 #ifdef PNG_FLOATING_POINT_SUPPORTED
nuclear@0 4016 #if defined(PNG_READ_GAMMA_SUPPORTED)
nuclear@0 4017 static PNG_CONST int png_gamma_shift[] =
nuclear@0 4018 {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};
nuclear@0 4019
nuclear@0 4020 /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
nuclear@0 4021 * tables, we don't make a full table if we are reducing to 8-bit in
nuclear@0 4022 * the future. Note also how the gamma_16 tables are segmented so that
nuclear@0 4023 * we don't need to allocate > 64K chunks for a full 16-bit table.
nuclear@0 4024 */
nuclear@0 4025 void /* PRIVATE */
nuclear@0 4026 png_build_gamma_table(png_structp png_ptr)
nuclear@0 4027 {
nuclear@0 4028 png_debug(1, "in png_build_gamma_table\n");
nuclear@0 4029
nuclear@0 4030 if (png_ptr->bit_depth <= 8)
nuclear@0 4031 {
nuclear@0 4032 int i;
nuclear@0 4033 double g;
nuclear@0 4034
nuclear@0 4035 if (png_ptr->screen_gamma > .000001)
nuclear@0 4036 g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
nuclear@0 4037 else
nuclear@0 4038 g = 1.0;
nuclear@0 4039
nuclear@0 4040 png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,
nuclear@0 4041 (png_uint_32)256);
nuclear@0 4042
nuclear@0 4043 for (i = 0; i < 256; i++)
nuclear@0 4044 {
nuclear@0 4045 png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,
nuclear@0 4046 g) * 255.0 + .5);
nuclear@0 4047 }
nuclear@0 4048
nuclear@0 4049 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
nuclear@0 4050 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
nuclear@0 4051 if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))
nuclear@0 4052 {
nuclear@0 4053
nuclear@0 4054 g = 1.0 / (png_ptr->gamma);
nuclear@0 4055
nuclear@0 4056 png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,
nuclear@0 4057 (png_uint_32)256);
nuclear@0 4058
nuclear@0 4059 for (i = 0; i < 256; i++)
nuclear@0 4060 {
nuclear@0 4061 png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,
nuclear@0 4062 g) * 255.0 + .5);
nuclear@0 4063 }
nuclear@0 4064
nuclear@0 4065
nuclear@0 4066 png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,
nuclear@0 4067 (png_uint_32)256);
nuclear@0 4068
nuclear@0 4069 if (png_ptr->screen_gamma > 0.000001)
nuclear@0 4070 g = 1.0 / png_ptr->screen_gamma;
nuclear@0 4071 else
nuclear@0 4072 g = png_ptr->gamma; /* probably doing rgb_to_gray */
nuclear@0 4073
nuclear@0 4074 for (i = 0; i < 256; i++)
nuclear@0 4075 {
nuclear@0 4076 png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,
nuclear@0 4077 g) * 255.0 + .5);
nuclear@0 4078
nuclear@0 4079 }
nuclear@0 4080 }
nuclear@0 4081 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
nuclear@0 4082 }
nuclear@0 4083 else
nuclear@0 4084 {
nuclear@0 4085 double g;
nuclear@0 4086 int i, j, shift, num;
nuclear@0 4087 int sig_bit;
nuclear@0 4088 png_uint_32 ig;
nuclear@0 4089
nuclear@0 4090 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
nuclear@0 4091 {
nuclear@0 4092 sig_bit = (int)png_ptr->sig_bit.red;
nuclear@0 4093 if ((int)png_ptr->sig_bit.green > sig_bit)
nuclear@0 4094 sig_bit = png_ptr->sig_bit.green;
nuclear@0 4095 if ((int)png_ptr->sig_bit.blue > sig_bit)
nuclear@0 4096 sig_bit = png_ptr->sig_bit.blue;
nuclear@0 4097 }
nuclear@0 4098 else
nuclear@0 4099 {
nuclear@0 4100 sig_bit = (int)png_ptr->sig_bit.gray;
nuclear@0 4101 }
nuclear@0 4102
nuclear@0 4103 if (sig_bit > 0)
nuclear@0 4104 shift = 16 - sig_bit;
nuclear@0 4105 else
nuclear@0 4106 shift = 0;
nuclear@0 4107
nuclear@0 4108 if (png_ptr->transformations & PNG_16_TO_8)
nuclear@0 4109 {
nuclear@0 4110 if (shift < (16 - PNG_MAX_GAMMA_8))
nuclear@0 4111 shift = (16 - PNG_MAX_GAMMA_8);
nuclear@0 4112 }
nuclear@0 4113
nuclear@0 4114 if (shift > 8)
nuclear@0 4115 shift = 8;
nuclear@0 4116 if (shift < 0)
nuclear@0 4117 shift = 0;
nuclear@0 4118
nuclear@0 4119 png_ptr->gamma_shift = (png_byte)shift;
nuclear@0 4120
nuclear@0 4121 num = (1 << (8 - shift));
nuclear@0 4122
nuclear@0 4123 if (png_ptr->screen_gamma > .000001)
nuclear@0 4124 g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
nuclear@0 4125 else
nuclear@0 4126 g = 1.0;
nuclear@0 4127
nuclear@0 4128 png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
nuclear@0 4129 (png_uint_32)(num * png_sizeof(png_uint_16p)));
nuclear@0 4130
nuclear@0 4131 if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
nuclear@0 4132 {
nuclear@0 4133 double fin, fout;
nuclear@0 4134 png_uint_32 last, max;
nuclear@0 4135
nuclear@0 4136 for (i = 0; i < num; i++)
nuclear@0 4137 {
nuclear@0 4138 png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
nuclear@0 4139 (png_uint_32)(256 * png_sizeof(png_uint_16)));
nuclear@0 4140 }
nuclear@0 4141
nuclear@0 4142 g = 1.0 / g;
nuclear@0 4143 last = 0;
nuclear@0 4144 for (i = 0; i < 256; i++)
nuclear@0 4145 {
nuclear@0 4146 fout = ((double)i + 0.5) / 256.0;
nuclear@0 4147 fin = pow(fout, g);
nuclear@0 4148 max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));
nuclear@0 4149 while (last <= max)
nuclear@0 4150 {
nuclear@0 4151 png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
nuclear@0 4152 [(int)(last >> (8 - shift))] = (png_uint_16)(
nuclear@0 4153 (png_uint_16)i | ((png_uint_16)i << 8));
nuclear@0 4154 last++;
nuclear@0 4155 }
nuclear@0 4156 }
nuclear@0 4157 while (last < ((png_uint_32)num << 8))
nuclear@0 4158 {
nuclear@0 4159 png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]
nuclear@0 4160 [(int)(last >> (8 - shift))] = (png_uint_16)65535L;
nuclear@0 4161 last++;
nuclear@0 4162 }
nuclear@0 4163 }
nuclear@0 4164 else
nuclear@0 4165 {
nuclear@0 4166 for (i = 0; i < num; i++)
nuclear@0 4167 {
nuclear@0 4168 png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
nuclear@0 4169 (png_uint_32)(256 * png_sizeof(png_uint_16)));
nuclear@0 4170
nuclear@0 4171 ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
nuclear@0 4172 for (j = 0; j < 256; j++)
nuclear@0 4173 {
nuclear@0 4174 png_ptr->gamma_16_table[i][j] =
nuclear@0 4175 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
nuclear@0 4176 65535.0, g) * 65535.0 + .5);
nuclear@0 4177 }
nuclear@0 4178 }
nuclear@0 4179 }
nuclear@0 4180
nuclear@0 4181 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
nuclear@0 4182 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
nuclear@0 4183 if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
nuclear@0 4184 {
nuclear@0 4185
nuclear@0 4186 g = 1.0 / (png_ptr->gamma);
nuclear@0 4187
nuclear@0 4188 png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
nuclear@0 4189 (png_uint_32)(num * png_sizeof(png_uint_16p )));
nuclear@0 4190
nuclear@0 4191 for (i = 0; i < num; i++)
nuclear@0 4192 {
nuclear@0 4193 png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
nuclear@0 4194 (png_uint_32)(256 * png_sizeof(png_uint_16)));
nuclear@0 4195
nuclear@0 4196 ig = (((png_uint_32)i *
nuclear@0 4197 (png_uint_32)png_gamma_shift[shift]) >> 4);
nuclear@0 4198 for (j = 0; j < 256; j++)
nuclear@0 4199 {
nuclear@0 4200 png_ptr->gamma_16_to_1[i][j] =
nuclear@0 4201 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
nuclear@0 4202 65535.0, g) * 65535.0 + .5);
nuclear@0 4203 }
nuclear@0 4204 }
nuclear@0 4205
nuclear@0 4206 if (png_ptr->screen_gamma > 0.000001)
nuclear@0 4207 g = 1.0 / png_ptr->screen_gamma;
nuclear@0 4208 else
nuclear@0 4209 g = png_ptr->gamma; /* probably doing rgb_to_gray */
nuclear@0 4210
nuclear@0 4211 png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
nuclear@0 4212 (png_uint_32)(num * png_sizeof(png_uint_16p)));
nuclear@0 4213
nuclear@0 4214 for (i = 0; i < num; i++)
nuclear@0 4215 {
nuclear@0 4216 png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
nuclear@0 4217 (png_uint_32)(256 * png_sizeof(png_uint_16)));
nuclear@0 4218
nuclear@0 4219 ig = (((png_uint_32)i *
nuclear@0 4220 (png_uint_32)png_gamma_shift[shift]) >> 4);
nuclear@0 4221 for (j = 0; j < 256; j++)
nuclear@0 4222 {
nuclear@0 4223 png_ptr->gamma_16_from_1[i][j] =
nuclear@0 4224 (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /
nuclear@0 4225 65535.0, g) * 65535.0 + .5);
nuclear@0 4226 }
nuclear@0 4227 }
nuclear@0 4228 }
nuclear@0 4229 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */
nuclear@0 4230 }
nuclear@0 4231 }
nuclear@0 4232 #endif
nuclear@0 4233 /* To do: install integer version of png_build_gamma_table here */
nuclear@0 4234 #endif
nuclear@0 4235
nuclear@0 4236 #if defined(PNG_MNG_FEATURES_SUPPORTED)
nuclear@0 4237 /* undoes intrapixel differencing */
nuclear@0 4238 void /* PRIVATE */
nuclear@0 4239 png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
nuclear@0 4240 {
nuclear@0 4241 png_debug(1, "in png_do_read_intrapixel\n");
nuclear@0 4242 if (
nuclear@0 4243 #if defined(PNG_USELESS_TESTS_SUPPORTED)
nuclear@0 4244 row != NULL && row_info != NULL &&
nuclear@0 4245 #endif
nuclear@0 4246 (row_info->color_type & PNG_COLOR_MASK_COLOR))
nuclear@0 4247 {
nuclear@0 4248 int bytes_per_pixel;
nuclear@0 4249 png_uint_32 row_width = row_info->width;
nuclear@0 4250 if (row_info->bit_depth == 8)
nuclear@0 4251 {
nuclear@0 4252 png_bytep rp;
nuclear@0 4253 png_uint_32 i;
nuclear@0 4254
nuclear@0 4255 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
nuclear@0 4256 bytes_per_pixel = 3;
nuclear@0 4257 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
nuclear@0 4258 bytes_per_pixel = 4;
nuclear@0 4259 else
nuclear@0 4260 return;
nuclear@0 4261
nuclear@0 4262 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
nuclear@0 4263 {
nuclear@0 4264 *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);
nuclear@0 4265 *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);
nuclear@0 4266 }
nuclear@0 4267 }
nuclear@0 4268 else if (row_info->bit_depth == 16)
nuclear@0 4269 {
nuclear@0 4270 png_bytep rp;
nuclear@0 4271 png_uint_32 i;
nuclear@0 4272
nuclear@0 4273 if (row_info->color_type == PNG_COLOR_TYPE_RGB)
nuclear@0 4274 bytes_per_pixel = 6;
nuclear@0 4275 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
nuclear@0 4276 bytes_per_pixel = 8;
nuclear@0 4277 else
nuclear@0 4278 return;
nuclear@0 4279
nuclear@0 4280 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
nuclear@0 4281 {
nuclear@0 4282 png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1);
nuclear@0 4283 png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);
nuclear@0 4284 png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);
nuclear@0 4285 png_uint_32 red = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);
nuclear@0 4286 png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);
nuclear@0 4287 *(rp ) = (png_byte)((red >> 8) & 0xff);
nuclear@0 4288 *(rp+1) = (png_byte)(red & 0xff);
nuclear@0 4289 *(rp+4) = (png_byte)((blue >> 8) & 0xff);
nuclear@0 4290 *(rp+5) = (png_byte)(blue & 0xff);
nuclear@0 4291 }
nuclear@0 4292 }
nuclear@0 4293 }
nuclear@0 4294 }
nuclear@0 4295 #endif /* PNG_MNG_FEATURES_SUPPORTED */
nuclear@0 4296 #endif /* PNG_READ_SUPPORTED */