1 /* pngrtran.c - transforms the data in a row for PNG readers 2 * 3 * Last changed in libpng 1.6.2 [April 25, 2013] 4 * Copyright (c) 1998-2013 Glenn Randers-Pehrson 5 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 6 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 7 * 8 * This code is released under the libpng license. 9 * For conditions of distribution and use, see the disclaimer 10 * and license in png.h 11 * 12 * This file contains functions optionally called by an application 13 * in order to tell libpng how to handle data when reading a PNG. 14 * Transformations that are used in both reading and writing are 15 * in pngtrans.c. 16 */ 17 18 #include "pngpriv.h" 19 20 #ifdef PNG_READ_SUPPORTED 21 22 /* Set the action on getting a CRC error for an ancillary or critical chunk. */ 23 void PNGAPI 24 png_set_crc_action(png_structrp png_ptr, int crit_action, int ancil_action) 25 { 26 png_debug(1, "in png_set_crc_action"); 27 28 if (png_ptr == NULL) 29 return; 30 31 /* Tell libpng how we react to CRC errors in critical chunks */ 32 switch (crit_action) 33 { 34 case PNG_CRC_NO_CHANGE: /* Leave setting as is */ 35 break; 36 37 case PNG_CRC_WARN_USE: /* Warn/use data */ 38 png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; 39 png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE; 40 break; 41 42 case PNG_CRC_QUIET_USE: /* Quiet/use data */ 43 png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; 44 png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE | 45 PNG_FLAG_CRC_CRITICAL_IGNORE; 46 break; 47 48 case PNG_CRC_WARN_DISCARD: /* Not a valid action for critical data */ 49 png_warning(png_ptr, 50 "Can't discard critical data on CRC error"); 51 case PNG_CRC_ERROR_QUIT: /* Error/quit */ 52 53 case PNG_CRC_DEFAULT: 54 default: 55 png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; 56 break; 57 } 58 59 /* Tell libpng how we react to CRC errors in ancillary chunks */ 60 switch (ancil_action) 61 { 62 case PNG_CRC_NO_CHANGE: /* Leave setting as is */ 63 break; 64 65 case PNG_CRC_WARN_USE: /* Warn/use data */ 66 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; 67 png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE; 68 break; 69 70 case PNG_CRC_QUIET_USE: /* Quiet/use data */ 71 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; 72 png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE | 73 PNG_FLAG_CRC_ANCILLARY_NOWARN; 74 break; 75 76 case PNG_CRC_ERROR_QUIT: /* Error/quit */ 77 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; 78 png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN; 79 break; 80 81 case PNG_CRC_WARN_DISCARD: /* Warn/discard data */ 82 83 case PNG_CRC_DEFAULT: 84 default: 85 png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; 86 break; 87 } 88 } 89 90 #ifdef PNG_READ_TRANSFORMS_SUPPORTED 91 /* Is it OK to set a transformation now? Only if png_start_read_image or 92 * png_read_update_info have not been called. It is not necessary for the IHDR 93 * to have been read in all cases, the parameter allows for this check too. 94 */ 95 static int 96 png_rtran_ok(png_structrp png_ptr, int need_IHDR) 97 { 98 if (png_ptr != NULL) 99 { 100 if (png_ptr->flags & PNG_FLAG_ROW_INIT) 101 png_app_error(png_ptr, 102 "invalid after png_start_read_image or png_read_update_info"); 103 104 else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0) 105 png_app_error(png_ptr, "invalid before the PNG header has been read"); 106 107 else 108 { 109 /* Turn on failure to initialize correctly for all transforms. */ 110 png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED; 111 112 return 1; /* Ok */ 113 } 114 } 115 116 return 0; /* no png_error possible! */ 117 } 118 #endif 119 120 #ifdef PNG_READ_BACKGROUND_SUPPORTED 121 /* Handle alpha and tRNS via a background color */ 122 void PNGFAPI 123 png_set_background_fixed(png_structrp png_ptr, 124 png_const_color_16p background_color, int background_gamma_code, 125 int need_expand, png_fixed_point background_gamma) 126 { 127 png_debug(1, "in png_set_background_fixed"); 128 129 if (!png_rtran_ok(png_ptr, 0) || background_color == NULL) 130 return; 131 132 if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) 133 { 134 png_warning(png_ptr, "Application must supply a known background gamma"); 135 return; 136 } 137 138 png_ptr->transformations |= PNG_COMPOSE | PNG_STRIP_ALPHA; 139 png_ptr->transformations &= ~PNG_ENCODE_ALPHA; 140 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 141 142 png_ptr->background = *background_color; 143 png_ptr->background_gamma = background_gamma; 144 png_ptr->background_gamma_type = (png_byte)(background_gamma_code); 145 if (need_expand) 146 png_ptr->transformations |= PNG_BACKGROUND_EXPAND; 147 else 148 png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; 149 } 150 151 # ifdef PNG_FLOATING_POINT_SUPPORTED 152 void PNGAPI 153 png_set_background(png_structrp png_ptr, 154 png_const_color_16p background_color, int background_gamma_code, 155 int need_expand, double background_gamma) 156 { 157 png_set_background_fixed(png_ptr, background_color, background_gamma_code, 158 need_expand, png_fixed(png_ptr, background_gamma, "png_set_background")); 159 } 160 # endif /* FLOATING_POINT */ 161 #endif /* READ_BACKGROUND */ 162 163 /* Scale 16-bit depth files to 8-bit depth. If both of these are set then the 164 * one that pngrtran does first (scale) happens. This is necessary to allow the 165 * TRANSFORM and API behavior to be somewhat consistent, and it's simpler. 166 */ 167 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED 168 void PNGAPI 169 png_set_scale_16(png_structrp png_ptr) 170 { 171 png_debug(1, "in png_set_scale_16"); 172 173 if (!png_rtran_ok(png_ptr, 0)) 174 return; 175 176 png_ptr->transformations |= PNG_SCALE_16_TO_8; 177 } 178 #endif 179 180 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED 181 /* Chop 16-bit depth files to 8-bit depth */ 182 void PNGAPI 183 png_set_strip_16(png_structrp png_ptr) 184 { 185 png_debug(1, "in png_set_strip_16"); 186 187 if (!png_rtran_ok(png_ptr, 0)) 188 return; 189 190 png_ptr->transformations |= PNG_16_TO_8; 191 } 192 #endif 193 194 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 195 void PNGAPI 196 png_set_strip_alpha(png_structrp png_ptr) 197 { 198 png_debug(1, "in png_set_strip_alpha"); 199 200 if (!png_rtran_ok(png_ptr, 0)) 201 return; 202 203 png_ptr->transformations |= PNG_STRIP_ALPHA; 204 } 205 #endif 206 207 #if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED) 208 static png_fixed_point 209 translate_gamma_flags(png_structrp png_ptr, png_fixed_point output_gamma, 210 int is_screen) 211 { 212 /* Check for flag values. The main reason for having the old Mac value as a 213 * flag is that it is pretty near impossible to work out what the correct 214 * value is from Apple documentation - a working Mac system is needed to 215 * discover the value! 216 */ 217 if (output_gamma == PNG_DEFAULT_sRGB || 218 output_gamma == PNG_FP_1 / PNG_DEFAULT_sRGB) 219 { 220 /* If there is no sRGB support this just sets the gamma to the standard 221 * sRGB value. (This is a side effect of using this function!) 222 */ 223 # ifdef PNG_READ_sRGB_SUPPORTED 224 png_ptr->flags |= PNG_FLAG_ASSUME_sRGB; 225 # else 226 PNG_UNUSED(png_ptr) 227 # endif 228 if (is_screen) 229 output_gamma = PNG_GAMMA_sRGB; 230 else 231 output_gamma = PNG_GAMMA_sRGB_INVERSE; 232 } 233 234 else if (output_gamma == PNG_GAMMA_MAC_18 || 235 output_gamma == PNG_FP_1 / PNG_GAMMA_MAC_18) 236 { 237 if (is_screen) 238 output_gamma = PNG_GAMMA_MAC_OLD; 239 else 240 output_gamma = PNG_GAMMA_MAC_INVERSE; 241 } 242 243 return output_gamma; 244 } 245 246 # ifdef PNG_FLOATING_POINT_SUPPORTED 247 static png_fixed_point 248 convert_gamma_value(png_structrp png_ptr, double output_gamma) 249 { 250 /* The following silently ignores cases where fixed point (times 100,000) 251 * gamma values are passed to the floating point API. This is safe and it 252 * means the fixed point constants work just fine with the floating point 253 * API. The alternative would just lead to undetected errors and spurious 254 * bug reports. Negative values fail inside the _fixed API unless they 255 * correspond to the flag values. 256 */ 257 if (output_gamma > 0 && output_gamma < 128) 258 output_gamma *= PNG_FP_1; 259 260 /* This preserves -1 and -2 exactly: */ 261 output_gamma = floor(output_gamma + .5); 262 263 if (output_gamma > PNG_FP_MAX || output_gamma < PNG_FP_MIN) 264 png_fixed_error(png_ptr, "gamma value"); 265 266 return (png_fixed_point)output_gamma; 267 } 268 # endif 269 #endif /* READ_ALPHA_MODE || READ_GAMMA */ 270 271 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED 272 void PNGFAPI 273 png_set_alpha_mode_fixed(png_structrp png_ptr, int mode, 274 png_fixed_point output_gamma) 275 { 276 int compose = 0; 277 png_fixed_point file_gamma; 278 279 png_debug(1, "in png_set_alpha_mode"); 280 281 if (!png_rtran_ok(png_ptr, 0)) 282 return; 283 284 output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/); 285 286 /* Validate the value to ensure it is in a reasonable range. The value 287 * is expected to be 1 or greater, but this range test allows for some 288 * viewing correction values. The intent is to weed out users of this API 289 * who use the inverse of the gamma value accidentally! Since some of these 290 * values are reasonable this may have to be changed. 291 */ 292 if (output_gamma < 70000 || output_gamma > 300000) 293 png_error(png_ptr, "output gamma out of expected range"); 294 295 /* The default file gamma is the inverse of the output gamma; the output 296 * gamma may be changed below so get the file value first: 297 */ 298 file_gamma = png_reciprocal(output_gamma); 299 300 /* There are really 8 possibilities here, composed of any combination 301 * of: 302 * 303 * premultiply the color channels 304 * do not encode non-opaque pixels 305 * encode the alpha as well as the color channels 306 * 307 * The differences disappear if the input/output ('screen') gamma is 1.0, 308 * because then the encoding is a no-op and there is only the choice of 309 * premultiplying the color channels or not. 310 * 311 * png_set_alpha_mode and png_set_background interact because both use 312 * png_compose to do the work. Calling both is only useful when 313 * png_set_alpha_mode is used to set the default mode - PNG_ALPHA_PNG - along 314 * with a default gamma value. Otherwise PNG_COMPOSE must not be set. 315 */ 316 switch (mode) 317 { 318 case PNG_ALPHA_PNG: /* default: png standard */ 319 /* No compose, but it may be set by png_set_background! */ 320 png_ptr->transformations &= ~PNG_ENCODE_ALPHA; 321 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 322 break; 323 324 case PNG_ALPHA_ASSOCIATED: /* color channels premultiplied */ 325 compose = 1; 326 png_ptr->transformations &= ~PNG_ENCODE_ALPHA; 327 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 328 /* The output is linear: */ 329 output_gamma = PNG_FP_1; 330 break; 331 332 case PNG_ALPHA_OPTIMIZED: /* associated, non-opaque pixels linear */ 333 compose = 1; 334 png_ptr->transformations &= ~PNG_ENCODE_ALPHA; 335 png_ptr->flags |= PNG_FLAG_OPTIMIZE_ALPHA; 336 /* output_gamma records the encoding of opaque pixels! */ 337 break; 338 339 case PNG_ALPHA_BROKEN: /* associated, non-linear, alpha encoded */ 340 compose = 1; 341 png_ptr->transformations |= PNG_ENCODE_ALPHA; 342 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 343 break; 344 345 default: 346 png_error(png_ptr, "invalid alpha mode"); 347 } 348 349 /* Only set the default gamma if the file gamma has not been set (this has 350 * the side effect that the gamma in a second call to png_set_alpha_mode will 351 * be ignored.) 352 */ 353 if (png_ptr->colorspace.gamma == 0) 354 { 355 png_ptr->colorspace.gamma = file_gamma; 356 png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; 357 } 358 359 /* But always set the output gamma: */ 360 png_ptr->screen_gamma = output_gamma; 361 362 /* Finally, if pre-multiplying, set the background fields to achieve the 363 * desired result. 364 */ 365 if (compose) 366 { 367 /* And obtain alpha pre-multiplication by composing on black: */ 368 memset(&png_ptr->background, 0, (sizeof png_ptr->background)); 369 png_ptr->background_gamma = png_ptr->colorspace.gamma; /* just in case */ 370 png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE; 371 png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; 372 373 if (png_ptr->transformations & PNG_COMPOSE) 374 png_error(png_ptr, 375 "conflicting calls to set alpha mode and background"); 376 377 png_ptr->transformations |= PNG_COMPOSE; 378 } 379 } 380 381 # ifdef PNG_FLOATING_POINT_SUPPORTED 382 void PNGAPI 383 png_set_alpha_mode(png_structrp png_ptr, int mode, double output_gamma) 384 { 385 png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr, 386 output_gamma)); 387 } 388 # endif 389 #endif 390 391 #ifdef PNG_READ_QUANTIZE_SUPPORTED 392 /* Dither file to 8-bit. Supply a palette, the current number 393 * of elements in the palette, the maximum number of elements 394 * allowed, and a histogram if possible. If the current number 395 * of colors is greater then the maximum number, the palette will be 396 * modified to fit in the maximum number. "full_quantize" indicates 397 * whether we need a quantizing cube set up for RGB images, or if we 398 * simply are reducing the number of colors in a paletted image. 399 */ 400 401 typedef struct png_dsort_struct 402 { 403 struct png_dsort_struct * next; 404 png_byte left; 405 png_byte right; 406 } png_dsort; 407 typedef png_dsort * png_dsortp; 408 typedef png_dsort * * png_dsortpp; 409 410 void PNGAPI 411 png_set_quantize(png_structrp png_ptr, png_colorp palette, 412 int num_palette, int maximum_colors, png_const_uint_16p histogram, 413 int full_quantize) 414 { 415 png_debug(1, "in png_set_quantize"); 416 417 if (!png_rtran_ok(png_ptr, 0)) 418 return; 419 420 png_ptr->transformations |= PNG_QUANTIZE; 421 422 if (!full_quantize) 423 { 424 int i; 425 426 png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr, 427 (png_uint_32)(num_palette * (sizeof (png_byte)))); 428 for (i = 0; i < num_palette; i++) 429 png_ptr->quantize_index[i] = (png_byte)i; 430 } 431 432 if (num_palette > maximum_colors) 433 { 434 if (histogram != NULL) 435 { 436 /* This is easy enough, just throw out the least used colors. 437 * Perhaps not the best solution, but good enough. 438 */ 439 440 int i; 441 442 /* Initialize an array to sort colors */ 443 png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr, 444 (png_uint_32)(num_palette * (sizeof (png_byte)))); 445 446 /* Initialize the quantize_sort array */ 447 for (i = 0; i < num_palette; i++) 448 png_ptr->quantize_sort[i] = (png_byte)i; 449 450 /* Find the least used palette entries by starting a 451 * bubble sort, and running it until we have sorted 452 * out enough colors. Note that we don't care about 453 * sorting all the colors, just finding which are 454 * least used. 455 */ 456 457 for (i = num_palette - 1; i >= maximum_colors; i--) 458 { 459 int done; /* To stop early if the list is pre-sorted */ 460 int j; 461 462 done = 1; 463 for (j = 0; j < i; j++) 464 { 465 if (histogram[png_ptr->quantize_sort[j]] 466 < histogram[png_ptr->quantize_sort[j + 1]]) 467 { 468 png_byte t; 469 470 t = png_ptr->quantize_sort[j]; 471 png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1]; 472 png_ptr->quantize_sort[j + 1] = t; 473 done = 0; 474 } 475 } 476 477 if (done) 478 break; 479 } 480 481 /* Swap the palette around, and set up a table, if necessary */ 482 if (full_quantize) 483 { 484 int j = num_palette; 485 486 /* Put all the useful colors within the max, but don't 487 * move the others. 488 */ 489 for (i = 0; i < maximum_colors; i++) 490 { 491 if ((int)png_ptr->quantize_sort[i] >= maximum_colors) 492 { 493 do 494 j--; 495 while ((int)png_ptr->quantize_sort[j] >= maximum_colors); 496 497 palette[i] = palette[j]; 498 } 499 } 500 } 501 else 502 { 503 int j = num_palette; 504 505 /* Move all the used colors inside the max limit, and 506 * develop a translation table. 507 */ 508 for (i = 0; i < maximum_colors; i++) 509 { 510 /* Only move the colors we need to */ 511 if ((int)png_ptr->quantize_sort[i] >= maximum_colors) 512 { 513 png_color tmp_color; 514 515 do 516 j--; 517 while ((int)png_ptr->quantize_sort[j] >= maximum_colors); 518 519 tmp_color = palette[j]; 520 palette[j] = palette[i]; 521 palette[i] = tmp_color; 522 /* Indicate where the color went */ 523 png_ptr->quantize_index[j] = (png_byte)i; 524 png_ptr->quantize_index[i] = (png_byte)j; 525 } 526 } 527 528 /* Find closest color for those colors we are not using */ 529 for (i = 0; i < num_palette; i++) 530 { 531 if ((int)png_ptr->quantize_index[i] >= maximum_colors) 532 { 533 int min_d, k, min_k, d_index; 534 535 /* Find the closest color to one we threw out */ 536 d_index = png_ptr->quantize_index[i]; 537 min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); 538 for (k = 1, min_k = 0; k < maximum_colors; k++) 539 { 540 int d; 541 542 d = PNG_COLOR_DIST(palette[d_index], palette[k]); 543 544 if (d < min_d) 545 { 546 min_d = d; 547 min_k = k; 548 } 549 } 550 /* Point to closest color */ 551 png_ptr->quantize_index[i] = (png_byte)min_k; 552 } 553 } 554 } 555 png_free(png_ptr, png_ptr->quantize_sort); 556 png_ptr->quantize_sort = NULL; 557 } 558 else 559 { 560 /* This is much harder to do simply (and quickly). Perhaps 561 * we need to go through a median cut routine, but those 562 * don't always behave themselves with only a few colors 563 * as input. So we will just find the closest two colors, 564 * and throw out one of them (chosen somewhat randomly). 565 * [We don't understand this at all, so if someone wants to 566 * work on improving it, be our guest - AED, GRP] 567 */ 568 int i; 569 int max_d; 570 int num_new_palette; 571 png_dsortp t; 572 png_dsortpp hash; 573 574 t = NULL; 575 576 /* Initialize palette index arrays */ 577 png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, 578 (png_uint_32)(num_palette * (sizeof (png_byte)))); 579 png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, 580 (png_uint_32)(num_palette * (sizeof (png_byte)))); 581 582 /* Initialize the sort array */ 583 for (i = 0; i < num_palette; i++) 584 { 585 png_ptr->index_to_palette[i] = (png_byte)i; 586 png_ptr->palette_to_index[i] = (png_byte)i; 587 } 588 589 hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 * 590 (sizeof (png_dsortp)))); 591 592 num_new_palette = num_palette; 593 594 /* Initial wild guess at how far apart the farthest pixel 595 * pair we will be eliminating will be. Larger 596 * numbers mean more areas will be allocated, Smaller 597 * numbers run the risk of not saving enough data, and 598 * having to do this all over again. 599 * 600 * I have not done extensive checking on this number. 601 */ 602 max_d = 96; 603 604 while (num_new_palette > maximum_colors) 605 { 606 for (i = 0; i < num_new_palette - 1; i++) 607 { 608 int j; 609 610 for (j = i + 1; j < num_new_palette; j++) 611 { 612 int d; 613 614 d = PNG_COLOR_DIST(palette[i], palette[j]); 615 616 if (d <= max_d) 617 { 618 619 t = (png_dsortp)png_malloc_warn(png_ptr, 620 (png_uint_32)(sizeof (png_dsort))); 621 622 if (t == NULL) 623 break; 624 625 t->next = hash[d]; 626 t->left = (png_byte)i; 627 t->right = (png_byte)j; 628 hash[d] = t; 629 } 630 } 631 if (t == NULL) 632 break; 633 } 634 635 if (t != NULL) 636 for (i = 0; i <= max_d; i++) 637 { 638 if (hash[i] != NULL) 639 { 640 png_dsortp p; 641 642 for (p = hash[i]; p; p = p->next) 643 { 644 if ((int)png_ptr->index_to_palette[p->left] 645 < num_new_palette && 646 (int)png_ptr->index_to_palette[p->right] 647 < num_new_palette) 648 { 649 int j, next_j; 650 651 if (num_new_palette & 0x01) 652 { 653 j = p->left; 654 next_j = p->right; 655 } 656 else 657 { 658 j = p->right; 659 next_j = p->left; 660 } 661 662 num_new_palette--; 663 palette[png_ptr->index_to_palette[j]] 664 = palette[num_new_palette]; 665 if (!full_quantize) 666 { 667 int k; 668 669 for (k = 0; k < num_palette; k++) 670 { 671 if (png_ptr->quantize_index[k] == 672 png_ptr->index_to_palette[j]) 673 png_ptr->quantize_index[k] = 674 png_ptr->index_to_palette[next_j]; 675 676 if ((int)png_ptr->quantize_index[k] == 677 num_new_palette) 678 png_ptr->quantize_index[k] = 679 png_ptr->index_to_palette[j]; 680 } 681 } 682 683 png_ptr->index_to_palette[png_ptr->palette_to_index 684 [num_new_palette]] = png_ptr->index_to_palette[j]; 685 686 png_ptr->palette_to_index[png_ptr->index_to_palette[j]] 687 = png_ptr->palette_to_index[num_new_palette]; 688 689 png_ptr->index_to_palette[j] = 690 (png_byte)num_new_palette; 691 692 png_ptr->palette_to_index[num_new_palette] = 693 (png_byte)j; 694 } 695 if (num_new_palette <= maximum_colors) 696 break; 697 } 698 if (num_new_palette <= maximum_colors) 699 break; 700 } 701 } 702 703 for (i = 0; i < 769; i++) 704 { 705 if (hash[i] != NULL) 706 { 707 png_dsortp p = hash[i]; 708 while (p) 709 { 710 t = p->next; 711 png_free(png_ptr, p); 712 p = t; 713 } 714 } 715 hash[i] = 0; 716 } 717 max_d += 96; 718 } 719 png_free(png_ptr, hash); 720 png_free(png_ptr, png_ptr->palette_to_index); 721 png_free(png_ptr, png_ptr->index_to_palette); 722 png_ptr->palette_to_index = NULL; 723 png_ptr->index_to_palette = NULL; 724 } 725 num_palette = maximum_colors; 726 } 727 if (png_ptr->palette == NULL) 728 { 729 png_ptr->palette = palette; 730 } 731 png_ptr->num_palette = (png_uint_16)num_palette; 732 733 if (full_quantize) 734 { 735 int i; 736 png_bytep distance; 737 int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS + 738 PNG_QUANTIZE_BLUE_BITS; 739 int num_red = (1 << PNG_QUANTIZE_RED_BITS); 740 int num_green = (1 << PNG_QUANTIZE_GREEN_BITS); 741 int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS); 742 png_size_t num_entries = ((png_size_t)1 << total_bits); 743 744 png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr, 745 (png_uint_32)(num_entries * (sizeof (png_byte)))); 746 747 distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * 748 (sizeof (png_byte)))); 749 750 memset(distance, 0xff, num_entries * (sizeof (png_byte))); 751 752 for (i = 0; i < num_palette; i++) 753 { 754 int ir, ig, ib; 755 int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS)); 756 int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS)); 757 int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS)); 758 759 for (ir = 0; ir < num_red; ir++) 760 { 761 /* int dr = abs(ir - r); */ 762 int dr = ((ir > r) ? ir - r : r - ir); 763 int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS + 764 PNG_QUANTIZE_GREEN_BITS)); 765 766 for (ig = 0; ig < num_green; ig++) 767 { 768 /* int dg = abs(ig - g); */ 769 int dg = ((ig > g) ? ig - g : g - ig); 770 int dt = dr + dg; 771 int dm = ((dr > dg) ? dr : dg); 772 int index_g = index_r | (ig << PNG_QUANTIZE_BLUE_BITS); 773 774 for (ib = 0; ib < num_blue; ib++) 775 { 776 int d_index = index_g | ib; 777 /* int db = abs(ib - b); */ 778 int db = ((ib > b) ? ib - b : b - ib); 779 int dmax = ((dm > db) ? dm : db); 780 int d = dmax + dt + db; 781 782 if (d < (int)distance[d_index]) 783 { 784 distance[d_index] = (png_byte)d; 785 png_ptr->palette_lookup[d_index] = (png_byte)i; 786 } 787 } 788 } 789 } 790 } 791 792 png_free(png_ptr, distance); 793 } 794 } 795 #endif /* PNG_READ_QUANTIZE_SUPPORTED */ 796 797 #ifdef PNG_READ_GAMMA_SUPPORTED 798 void PNGFAPI 799 png_set_gamma_fixed(png_structrp png_ptr, png_fixed_point scrn_gamma, 800 png_fixed_point file_gamma) 801 { 802 png_debug(1, "in png_set_gamma_fixed"); 803 804 if (!png_rtran_ok(png_ptr, 0)) 805 return; 806 807 /* New in libpng-1.5.4 - reserve particular negative values as flags. */ 808 scrn_gamma = translate_gamma_flags(png_ptr, scrn_gamma, 1/*screen*/); 809 file_gamma = translate_gamma_flags(png_ptr, file_gamma, 0/*file*/); 810 811 /* Checking the gamma values for being >0 was added in 1.5.4 along with the 812 * premultiplied alpha support; this actually hides an undocumented feature 813 * of the previous implementation which allowed gamma processing to be 814 * disabled in background handling. There is no evidence (so far) that this 815 * was being used; however, png_set_background itself accepted and must still 816 * accept '0' for the gamma value it takes, because it isn't always used. 817 * 818 * Since this is an API change (albeit a very minor one that removes an 819 * undocumented API feature) the following checks were only enabled in 820 * libpng-1.6.0. 821 */ 822 if (file_gamma <= 0) 823 png_error(png_ptr, "invalid file gamma in png_set_gamma"); 824 825 if (scrn_gamma <= 0) 826 png_error(png_ptr, "invalid screen gamma in png_set_gamma"); 827 828 /* Set the gamma values unconditionally - this overrides the value in the PNG 829 * file if a gAMA chunk was present. png_set_alpha_mode provides a 830 * different, easier, way to default the file gamma. 831 */ 832 png_ptr->colorspace.gamma = file_gamma; 833 png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; 834 png_ptr->screen_gamma = scrn_gamma; 835 } 836 837 # ifdef PNG_FLOATING_POINT_SUPPORTED 838 void PNGAPI 839 png_set_gamma(png_structrp png_ptr, double scrn_gamma, double file_gamma) 840 { 841 png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma), 842 convert_gamma_value(png_ptr, file_gamma)); 843 } 844 # endif /* FLOATING_POINT_SUPPORTED */ 845 #endif /* READ_GAMMA */ 846 847 #ifdef PNG_READ_EXPAND_SUPPORTED 848 /* Expand paletted images to RGB, expand grayscale images of 849 * less than 8-bit depth to 8-bit depth, and expand tRNS chunks 850 * to alpha channels. 851 */ 852 void PNGAPI 853 png_set_expand(png_structrp png_ptr) 854 { 855 png_debug(1, "in png_set_expand"); 856 857 if (!png_rtran_ok(png_ptr, 0)) 858 return; 859 860 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); 861 } 862 863 /* GRR 19990627: the following three functions currently are identical 864 * to png_set_expand(). However, it is entirely reasonable that someone 865 * might wish to expand an indexed image to RGB but *not* expand a single, 866 * fully transparent palette entry to a full alpha channel--perhaps instead 867 * convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace 868 * the transparent color with a particular RGB value, or drop tRNS entirely. 869 * IOW, a future version of the library may make the transformations flag 870 * a bit more fine-grained, with separate bits for each of these three 871 * functions. 872 * 873 * More to the point, these functions make it obvious what libpng will be 874 * doing, whereas "expand" can (and does) mean any number of things. 875 * 876 * GRP 20060307: In libpng-1.2.9, png_set_gray_1_2_4_to_8() was modified 877 * to expand only the sample depth but not to expand the tRNS to alpha 878 * and its name was changed to png_set_expand_gray_1_2_4_to_8(). 879 */ 880 881 /* Expand paletted images to RGB. */ 882 void PNGAPI 883 png_set_palette_to_rgb(png_structrp png_ptr) 884 { 885 png_debug(1, "in png_set_palette_to_rgb"); 886 887 if (!png_rtran_ok(png_ptr, 0)) 888 return; 889 890 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); 891 } 892 893 /* Expand grayscale images of less than 8-bit depth to 8 bits. */ 894 void PNGAPI 895 png_set_expand_gray_1_2_4_to_8(png_structrp png_ptr) 896 { 897 png_debug(1, "in png_set_expand_gray_1_2_4_to_8"); 898 899 if (!png_rtran_ok(png_ptr, 0)) 900 return; 901 902 png_ptr->transformations |= PNG_EXPAND; 903 } 904 905 /* Expand tRNS chunks to alpha channels. */ 906 void PNGAPI 907 png_set_tRNS_to_alpha(png_structrp png_ptr) 908 { 909 png_debug(1, "in png_set_tRNS_to_alpha"); 910 911 if (!png_rtran_ok(png_ptr, 0)) 912 return; 913 914 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); 915 } 916 #endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ 917 918 #ifdef PNG_READ_EXPAND_16_SUPPORTED 919 /* Expand to 16-bit channels, expand the tRNS chunk too (because otherwise 920 * it may not work correctly.) 921 */ 922 void PNGAPI 923 png_set_expand_16(png_structrp png_ptr) 924 { 925 png_debug(1, "in png_set_expand_16"); 926 927 if (!png_rtran_ok(png_ptr, 0)) 928 return; 929 930 png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS); 931 } 932 #endif 933 934 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 935 void PNGAPI 936 png_set_gray_to_rgb(png_structrp png_ptr) 937 { 938 png_debug(1, "in png_set_gray_to_rgb"); 939 940 if (!png_rtran_ok(png_ptr, 0)) 941 return; 942 943 /* Because rgb must be 8 bits or more: */ 944 png_set_expand_gray_1_2_4_to_8(png_ptr); 945 png_ptr->transformations |= PNG_GRAY_TO_RGB; 946 } 947 #endif 948 949 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 950 void PNGFAPI 951 png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action, 952 png_fixed_point red, png_fixed_point green) 953 { 954 png_debug(1, "in png_set_rgb_to_gray"); 955 956 /* Need the IHDR here because of the check on color_type below. */ 957 /* TODO: fix this */ 958 if (!png_rtran_ok(png_ptr, 1)) 959 return; 960 961 switch(error_action) 962 { 963 case PNG_ERROR_ACTION_NONE: 964 png_ptr->transformations |= PNG_RGB_TO_GRAY; 965 break; 966 967 case PNG_ERROR_ACTION_WARN: 968 png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; 969 break; 970 971 case PNG_ERROR_ACTION_ERROR: 972 png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; 973 break; 974 975 default: 976 png_error(png_ptr, "invalid error action to rgb_to_gray"); 977 break; 978 } 979 980 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 981 #ifdef PNG_READ_EXPAND_SUPPORTED 982 png_ptr->transformations |= PNG_EXPAND; 983 #else 984 { 985 /* Make this an error in 1.6 because otherwise the application may assume 986 * that it just worked and get a memory overwrite. 987 */ 988 png_error(png_ptr, 989 "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED"); 990 991 /* png_ptr->transformations &= ~PNG_RGB_TO_GRAY; */ 992 } 993 #endif 994 { 995 if (red >= 0 && green >= 0 && red + green <= PNG_FP_1) 996 { 997 png_uint_16 red_int, green_int; 998 999 /* NOTE: this calculation does not round, but this behavior is retained 1000 * for consistency, the inaccuracy is very small. The code here always 1001 * overwrites the coefficients, regardless of whether they have been 1002 * defaulted or set already. 1003 */ 1004 red_int = (png_uint_16)(((png_uint_32)red*32768)/100000); 1005 green_int = (png_uint_16)(((png_uint_32)green*32768)/100000); 1006 1007 png_ptr->rgb_to_gray_red_coeff = red_int; 1008 png_ptr->rgb_to_gray_green_coeff = green_int; 1009 png_ptr->rgb_to_gray_coefficients_set = 1; 1010 } 1011 1012 else 1013 { 1014 if (red >= 0 && green >= 0) 1015 png_app_warning(png_ptr, 1016 "ignoring out of range rgb_to_gray coefficients"); 1017 1018 /* Use the defaults, from the cHRM chunk if set, else the historical 1019 * values which are close to the sRGB/HDTV/ITU-Rec 709 values. See 1020 * png_do_rgb_to_gray for more discussion of the values. In this case 1021 * the coefficients are not marked as 'set' and are not overwritten if 1022 * something has already provided a default. 1023 */ 1024 if (png_ptr->rgb_to_gray_red_coeff == 0 && 1025 png_ptr->rgb_to_gray_green_coeff == 0) 1026 { 1027 png_ptr->rgb_to_gray_red_coeff = 6968; 1028 png_ptr->rgb_to_gray_green_coeff = 23434; 1029 /* png_ptr->rgb_to_gray_blue_coeff = 2366; */ 1030 } 1031 } 1032 } 1033 } 1034 1035 #ifdef PNG_FLOATING_POINT_SUPPORTED 1036 /* Convert a RGB image to a grayscale of the same width. This allows us, 1037 * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. 1038 */ 1039 1040 void PNGAPI 1041 png_set_rgb_to_gray(png_structrp png_ptr, int error_action, double red, 1042 double green) 1043 { 1044 png_set_rgb_to_gray_fixed(png_ptr, error_action, 1045 png_fixed(png_ptr, red, "rgb to gray red coefficient"), 1046 png_fixed(png_ptr, green, "rgb to gray green coefficient")); 1047 } 1048 #endif /* FLOATING POINT */ 1049 1050 #endif /* RGB_TO_GRAY */ 1051 1052 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ 1053 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) 1054 void PNGAPI 1055 png_set_read_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr 1056 read_user_transform_fn) 1057 { 1058 png_debug(1, "in png_set_read_user_transform_fn"); 1059 1060 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED 1061 png_ptr->transformations |= PNG_USER_TRANSFORM; 1062 png_ptr->read_user_transform_fn = read_user_transform_fn; 1063 #endif 1064 } 1065 #endif 1066 1067 #ifdef PNG_READ_TRANSFORMS_SUPPORTED 1068 #ifdef PNG_READ_GAMMA_SUPPORTED 1069 /* In the case of gamma transformations only do transformations on images where 1070 * the [file] gamma and screen_gamma are not close reciprocals, otherwise it 1071 * slows things down slightly, and also needlessly introduces small errors. 1072 */ 1073 static int /* PRIVATE */ 1074 png_gamma_threshold(png_fixed_point screen_gamma, png_fixed_point file_gamma) 1075 { 1076 /* PNG_GAMMA_THRESHOLD is the threshold for performing gamma 1077 * correction as a difference of the overall transform from 1.0 1078 * 1079 * We want to compare the threshold with s*f - 1, if we get 1080 * overflow here it is because of wacky gamma values so we 1081 * turn on processing anyway. 1082 */ 1083 png_fixed_point gtest; 1084 return !png_muldiv(>est, screen_gamma, file_gamma, PNG_FP_1) || 1085 png_gamma_significant(gtest); 1086 } 1087 #endif 1088 1089 /* Initialize everything needed for the read. This includes modifying 1090 * the palette. 1091 */ 1092 1093 /*For the moment 'png_init_palette_transformations' and 1094 * 'png_init_rgb_transformations' only do some flag canceling optimizations. 1095 * The intent is that these two routines should have palette or rgb operations 1096 * extracted from 'png_init_read_transformations'. 1097 */ 1098 static void /* PRIVATE */ 1099 png_init_palette_transformations(png_structrp png_ptr) 1100 { 1101 /* Called to handle the (input) palette case. In png_do_read_transformations 1102 * the first step is to expand the palette if requested, so this code must 1103 * take care to only make changes that are invariant with respect to the 1104 * palette expansion, or only do them if there is no expansion. 1105 * 1106 * STRIP_ALPHA has already been handled in the caller (by setting num_trans 1107 * to 0.) 1108 */ 1109 int input_has_alpha = 0; 1110 int input_has_transparency = 0; 1111 1112 if (png_ptr->num_trans > 0) 1113 { 1114 int i; 1115 1116 /* Ignore if all the entries are opaque (unlikely!) */ 1117 for (i=0; i<png_ptr->num_trans; ++i) 1118 if (png_ptr->trans_alpha[i] == 255) 1119 continue; 1120 else if (png_ptr->trans_alpha[i] == 0) 1121 input_has_transparency = 1; 1122 else 1123 input_has_alpha = 1; 1124 } 1125 1126 /* If no alpha we can optimize. */ 1127 if (!input_has_alpha) 1128 { 1129 /* Any alpha means background and associative alpha processing is 1130 * required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA 1131 * and ENCODE_ALPHA are irrelevant. 1132 */ 1133 png_ptr->transformations &= ~PNG_ENCODE_ALPHA; 1134 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 1135 1136 if (!input_has_transparency) 1137 png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); 1138 } 1139 1140 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) 1141 /* png_set_background handling - deals with the complexity of whether the 1142 * background color is in the file format or the screen format in the case 1143 * where an 'expand' will happen. 1144 */ 1145 1146 /* The following code cannot be entered in the alpha pre-multiplication case 1147 * because PNG_BACKGROUND_EXPAND is cancelled below. 1148 */ 1149 if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && 1150 (png_ptr->transformations & PNG_EXPAND)) 1151 { 1152 { 1153 png_ptr->background.red = 1154 png_ptr->palette[png_ptr->background.index].red; 1155 png_ptr->background.green = 1156 png_ptr->palette[png_ptr->background.index].green; 1157 png_ptr->background.blue = 1158 png_ptr->palette[png_ptr->background.index].blue; 1159 1160 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED 1161 if (png_ptr->transformations & PNG_INVERT_ALPHA) 1162 { 1163 if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) 1164 { 1165 /* Invert the alpha channel (in tRNS) unless the pixels are 1166 * going to be expanded, in which case leave it for later 1167 */ 1168 int i, istop = png_ptr->num_trans; 1169 1170 for (i=0; i<istop; i++) 1171 png_ptr->trans_alpha[i] = (png_byte)(255 - 1172 png_ptr->trans_alpha[i]); 1173 } 1174 } 1175 #endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */ 1176 } 1177 } /* background expand and (therefore) no alpha association. */ 1178 #endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ 1179 } 1180 1181 static void /* PRIVATE */ 1182 png_init_rgb_transformations(png_structrp png_ptr) 1183 { 1184 /* Added to libpng-1.5.4: check the color type to determine whether there 1185 * is any alpha or transparency in the image and simply cancel the 1186 * background and alpha mode stuff if there isn't. 1187 */ 1188 int input_has_alpha = (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0; 1189 int input_has_transparency = png_ptr->num_trans > 0; 1190 1191 /* If no alpha we can optimize. */ 1192 if (!input_has_alpha) 1193 { 1194 /* Any alpha means background and associative alpha processing is 1195 * required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA 1196 * and ENCODE_ALPHA are irrelevant. 1197 */ 1198 # ifdef PNG_READ_ALPHA_MODE_SUPPORTED 1199 png_ptr->transformations &= ~PNG_ENCODE_ALPHA; 1200 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 1201 # endif 1202 1203 if (!input_has_transparency) 1204 png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); 1205 } 1206 1207 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) 1208 /* png_set_background handling - deals with the complexity of whether the 1209 * background color is in the file format or the screen format in the case 1210 * where an 'expand' will happen. 1211 */ 1212 1213 /* The following code cannot be entered in the alpha pre-multiplication case 1214 * because PNG_BACKGROUND_EXPAND is cancelled below. 1215 */ 1216 if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && 1217 (png_ptr->transformations & PNG_EXPAND) && 1218 !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) 1219 /* i.e., GRAY or GRAY_ALPHA */ 1220 { 1221 { 1222 /* Expand background and tRNS chunks */ 1223 int gray = png_ptr->background.gray; 1224 int trans_gray = png_ptr->trans_color.gray; 1225 1226 switch (png_ptr->bit_depth) 1227 { 1228 case 1: 1229 gray *= 0xff; 1230 trans_gray *= 0xff; 1231 break; 1232 1233 case 2: 1234 gray *= 0x55; 1235 trans_gray *= 0x55; 1236 break; 1237 1238 case 4: 1239 gray *= 0x11; 1240 trans_gray *= 0x11; 1241 break; 1242 1243 default: 1244 1245 case 8: 1246 /* FALL THROUGH (Already 8 bits) */ 1247 1248 case 16: 1249 /* Already a full 16 bits */ 1250 break; 1251 } 1252 1253 png_ptr->background.red = png_ptr->background.green = 1254 png_ptr->background.blue = (png_uint_16)gray; 1255 1256 if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) 1257 { 1258 png_ptr->trans_color.red = png_ptr->trans_color.green = 1259 png_ptr->trans_color.blue = (png_uint_16)trans_gray; 1260 } 1261 } 1262 } /* background expand and (therefore) no alpha association. */ 1263 #endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ 1264 } 1265 1266 void /* PRIVATE */ 1267 png_init_read_transformations(png_structrp png_ptr) 1268 { 1269 png_debug(1, "in png_init_read_transformations"); 1270 1271 /* This internal function is called from png_read_start_row in pngrutil.c 1272 * and it is called before the 'rowbytes' calculation is done, so the code 1273 * in here can change or update the transformations flags. 1274 * 1275 * First do updates that do not depend on the details of the PNG image data 1276 * being processed. 1277 */ 1278 1279 #ifdef PNG_READ_GAMMA_SUPPORTED 1280 /* Prior to 1.5.4 these tests were performed from png_set_gamma, 1.5.4 adds 1281 * png_set_alpha_mode and this is another source for a default file gamma so 1282 * the test needs to be performed later - here. In addition prior to 1.5.4 1283 * the tests were repeated for the PALETTE color type here - this is no 1284 * longer necessary (and doesn't seem to have been necessary before.) 1285 */ 1286 { 1287 /* The following temporary indicates if overall gamma correction is 1288 * required. 1289 */ 1290 int gamma_correction = 0; 1291 1292 if (png_ptr->colorspace.gamma != 0) /* has been set */ 1293 { 1294 if (png_ptr->screen_gamma != 0) /* screen set too */ 1295 gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma, 1296 png_ptr->screen_gamma); 1297 1298 else 1299 /* Assume the output matches the input; a long time default behavior 1300 * of libpng, although the standard has nothing to say about this. 1301 */ 1302 png_ptr->screen_gamma = png_reciprocal(png_ptr->colorspace.gamma); 1303 } 1304 1305 else if (png_ptr->screen_gamma != 0) 1306 /* The converse - assume the file matches the screen, note that this 1307 * perhaps undesireable default can (from 1.5.4) be changed by calling 1308 * png_set_alpha_mode (even if the alpha handling mode isn't required 1309 * or isn't changed from the default.) 1310 */ 1311 png_ptr->colorspace.gamma = png_reciprocal(png_ptr->screen_gamma); 1312 1313 else /* neither are set */ 1314 /* Just in case the following prevents any processing - file and screen 1315 * are both assumed to be linear and there is no way to introduce a 1316 * third gamma value other than png_set_background with 'UNIQUE', and, 1317 * prior to 1.5.4 1318 */ 1319 png_ptr->screen_gamma = png_ptr->colorspace.gamma = PNG_FP_1; 1320 1321 /* We have a gamma value now. */ 1322 png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; 1323 1324 /* Now turn the gamma transformation on or off as appropriate. Notice 1325 * that PNG_GAMMA just refers to the file->screen correction. Alpha 1326 * composition may independently cause gamma correction because it needs 1327 * linear data (e.g. if the file has a gAMA chunk but the screen gamma 1328 * hasn't been specified.) In any case this flag may get turned off in 1329 * the code immediately below if the transform can be handled outside the 1330 * row loop. 1331 */ 1332 if (gamma_correction) 1333 png_ptr->transformations |= PNG_GAMMA; 1334 1335 else 1336 png_ptr->transformations &= ~PNG_GAMMA; 1337 } 1338 #endif 1339 1340 /* Certain transformations have the effect of preventing other 1341 * transformations that happen afterward in png_do_read_transformations, 1342 * resolve the interdependencies here. From the code of 1343 * png_do_read_transformations the order is: 1344 * 1345 * 1) PNG_EXPAND (including PNG_EXPAND_tRNS) 1346 * 2) PNG_STRIP_ALPHA (if no compose) 1347 * 3) PNG_RGB_TO_GRAY 1348 * 4) PNG_GRAY_TO_RGB iff !PNG_BACKGROUND_IS_GRAY 1349 * 5) PNG_COMPOSE 1350 * 6) PNG_GAMMA 1351 * 7) PNG_STRIP_ALPHA (if compose) 1352 * 8) PNG_ENCODE_ALPHA 1353 * 9) PNG_SCALE_16_TO_8 1354 * 10) PNG_16_TO_8 1355 * 11) PNG_QUANTIZE (converts to palette) 1356 * 12) PNG_EXPAND_16 1357 * 13) PNG_GRAY_TO_RGB iff PNG_BACKGROUND_IS_GRAY 1358 * 14) PNG_INVERT_MONO 1359 * 15) PNG_SHIFT 1360 * 16) PNG_PACK 1361 * 17) PNG_BGR 1362 * 18) PNG_PACKSWAP 1363 * 19) PNG_FILLER (includes PNG_ADD_ALPHA) 1364 * 20) PNG_INVERT_ALPHA 1365 * 21) PNG_SWAP_ALPHA 1366 * 22) PNG_SWAP_BYTES 1367 * 23) PNG_USER_TRANSFORM [must be last] 1368 */ 1369 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 1370 if ((png_ptr->transformations & PNG_STRIP_ALPHA) && 1371 !(png_ptr->transformations & PNG_COMPOSE)) 1372 { 1373 /* Stripping the alpha channel happens immediately after the 'expand' 1374 * transformations, before all other transformation, so it cancels out 1375 * the alpha handling. It has the side effect negating the effect of 1376 * PNG_EXPAND_tRNS too: 1377 */ 1378 png_ptr->transformations &= ~(PNG_BACKGROUND_EXPAND | PNG_ENCODE_ALPHA | 1379 PNG_EXPAND_tRNS); 1380 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 1381 1382 /* Kill the tRNS chunk itself too. Prior to 1.5.4 this did not happen 1383 * so transparency information would remain just so long as it wasn't 1384 * expanded. This produces unexpected API changes if the set of things 1385 * that do PNG_EXPAND_tRNS changes (perfectly possible given the 1386 * documentation - which says ask for what you want, accept what you 1387 * get.) This makes the behavior consistent from 1.5.4: 1388 */ 1389 png_ptr->num_trans = 0; 1390 } 1391 #endif /* STRIP_ALPHA supported, no COMPOSE */ 1392 1393 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED 1394 /* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA 1395 * settings will have no effect. 1396 */ 1397 if (!png_gamma_significant(png_ptr->screen_gamma)) 1398 { 1399 png_ptr->transformations &= ~PNG_ENCODE_ALPHA; 1400 png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; 1401 } 1402 #endif 1403 1404 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 1405 /* Make sure the coefficients for the rgb to gray conversion are set 1406 * appropriately. 1407 */ 1408 if (png_ptr->transformations & PNG_RGB_TO_GRAY) 1409 png_colorspace_set_rgb_coefficients(png_ptr); 1410 #endif 1411 1412 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 1413 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) 1414 /* Detect gray background and attempt to enable optimization for 1415 * gray --> RGB case. 1416 * 1417 * Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or 1418 * RGB_ALPHA (in which case need_expand is superfluous anyway), the 1419 * background color might actually be gray yet not be flagged as such. 1420 * This is not a problem for the current code, which uses 1421 * PNG_BACKGROUND_IS_GRAY only to decide when to do the 1422 * png_do_gray_to_rgb() transformation. 1423 * 1424 * TODO: this code needs to be revised to avoid the complexity and 1425 * interdependencies. The color type of the background should be recorded in 1426 * png_set_background, along with the bit depth, then the code has a record 1427 * of exactly what color space the background is currently in. 1428 */ 1429 if (png_ptr->transformations & PNG_BACKGROUND_EXPAND) 1430 { 1431 /* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if 1432 * the file was grayscale the background value is gray. 1433 */ 1434 if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) 1435 png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; 1436 } 1437 1438 else if (png_ptr->transformations & PNG_COMPOSE) 1439 { 1440 /* PNG_COMPOSE: png_set_background was called with need_expand false, 1441 * so the color is in the color space of the output or png_set_alpha_mode 1442 * was called and the color is black. Ignore RGB_TO_GRAY because that 1443 * happens before GRAY_TO_RGB. 1444 */ 1445 if (png_ptr->transformations & PNG_GRAY_TO_RGB) 1446 { 1447 if (png_ptr->background.red == png_ptr->background.green && 1448 png_ptr->background.red == png_ptr->background.blue) 1449 { 1450 png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; 1451 png_ptr->background.gray = png_ptr->background.red; 1452 } 1453 } 1454 } 1455 #endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ 1456 #endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED */ 1457 1458 /* For indexed PNG data (PNG_COLOR_TYPE_PALETTE) many of the transformations 1459 * can be performed directly on the palette, and some (such as rgb to gray) 1460 * can be optimized inside the palette. This is particularly true of the 1461 * composite (background and alpha) stuff, which can be pretty much all done 1462 * in the palette even if the result is expanded to RGB or gray afterward. 1463 * 1464 * NOTE: this is Not Yet Implemented, the code behaves as in 1.5.1 and 1465 * earlier and the palette stuff is actually handled on the first row. This 1466 * leads to the reported bug that the palette returned by png_get_PLTE is not 1467 * updated. 1468 */ 1469 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 1470 png_init_palette_transformations(png_ptr); 1471 1472 else 1473 png_init_rgb_transformations(png_ptr); 1474 1475 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ 1476 defined(PNG_READ_EXPAND_16_SUPPORTED) 1477 if ((png_ptr->transformations & PNG_EXPAND_16) && 1478 (png_ptr->transformations & PNG_COMPOSE) && 1479 !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && 1480 png_ptr->bit_depth != 16) 1481 { 1482 /* TODO: fix this. Because the expand_16 operation is after the compose 1483 * handling the background color must be 8, not 16, bits deep, but the 1484 * application will supply a 16-bit value so reduce it here. 1485 * 1486 * The PNG_BACKGROUND_EXPAND code above does not expand to 16 bits at 1487 * present, so that case is ok (until do_expand_16 is moved.) 1488 * 1489 * NOTE: this discards the low 16 bits of the user supplied background 1490 * color, but until expand_16 works properly there is no choice! 1491 */ 1492 # define CHOP(x) (x)=((png_uint_16)PNG_DIV257(x)) 1493 CHOP(png_ptr->background.red); 1494 CHOP(png_ptr->background.green); 1495 CHOP(png_ptr->background.blue); 1496 CHOP(png_ptr->background.gray); 1497 # undef CHOP 1498 } 1499 #endif /* PNG_READ_BACKGROUND_SUPPORTED && PNG_READ_EXPAND_16_SUPPORTED */ 1500 1501 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ 1502 (defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \ 1503 defined(PNG_READ_STRIP_16_TO_8_SUPPORTED)) 1504 if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) && 1505 (png_ptr->transformations & PNG_COMPOSE) && 1506 !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && 1507 png_ptr->bit_depth == 16) 1508 { 1509 /* On the other hand, if a 16-bit file is to be reduced to 8-bits per 1510 * component this will also happen after PNG_COMPOSE and so the background 1511 * color must be pre-expanded here. 1512 * 1513 * TODO: fix this too. 1514 */ 1515 png_ptr->background.red = (png_uint_16)(png_ptr->background.red * 257); 1516 png_ptr->background.green = 1517 (png_uint_16)(png_ptr->background.green * 257); 1518 png_ptr->background.blue = (png_uint_16)(png_ptr->background.blue * 257); 1519 png_ptr->background.gray = (png_uint_16)(png_ptr->background.gray * 257); 1520 } 1521 #endif 1522 1523 /* NOTE: below 'PNG_READ_ALPHA_MODE_SUPPORTED' is presumed to also enable the 1524 * background support (see the comments in scripts/pnglibconf.dfa), this 1525 * allows pre-multiplication of the alpha channel to be implemented as 1526 * compositing on black. This is probably sub-optimal and has been done in 1527 * 1.5.4 betas simply to enable external critique and testing (i.e. to 1528 * implement the new API quickly, without lots of internal changes.) 1529 */ 1530 1531 #ifdef PNG_READ_GAMMA_SUPPORTED 1532 # ifdef PNG_READ_BACKGROUND_SUPPORTED 1533 /* Includes ALPHA_MODE */ 1534 png_ptr->background_1 = png_ptr->background; 1535 # endif 1536 1537 /* This needs to change - in the palette image case a whole set of tables are 1538 * built when it would be quicker to just calculate the correct value for 1539 * each palette entry directly. Also, the test is too tricky - why check 1540 * PNG_RGB_TO_GRAY if PNG_GAMMA is not set? The answer seems to be that 1541 * PNG_GAMMA is cancelled even if the gamma is known? The test excludes the 1542 * PNG_COMPOSE case, so apparently if there is no *overall* gamma correction 1543 * the gamma tables will not be built even if composition is required on a 1544 * gamma encoded value. 1545 * 1546 * In 1.5.4 this is addressed below by an additional check on the individual 1547 * file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the 1548 * tables. 1549 */ 1550 if ((png_ptr->transformations & PNG_GAMMA) 1551 || ((png_ptr->transformations & PNG_RGB_TO_GRAY) 1552 && (png_gamma_significant(png_ptr->colorspace.gamma) || 1553 png_gamma_significant(png_ptr->screen_gamma))) 1554 || ((png_ptr->transformations & PNG_COMPOSE) 1555 && (png_gamma_significant(png_ptr->colorspace.gamma) 1556 || png_gamma_significant(png_ptr->screen_gamma) 1557 # ifdef PNG_READ_BACKGROUND_SUPPORTED 1558 || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE 1559 && png_gamma_significant(png_ptr->background_gamma)) 1560 # endif 1561 )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) 1562 && png_gamma_significant(png_ptr->screen_gamma)) 1563 ) 1564 { 1565 png_build_gamma_table(png_ptr, png_ptr->bit_depth); 1566 1567 #ifdef PNG_READ_BACKGROUND_SUPPORTED 1568 if (png_ptr->transformations & PNG_COMPOSE) 1569 { 1570 /* Issue a warning about this combination: because RGB_TO_GRAY is 1571 * optimized to do the gamma transform if present yet do_background has 1572 * to do the same thing if both options are set a 1573 * double-gamma-correction happens. This is true in all versions of 1574 * libpng to date. 1575 */ 1576 if (png_ptr->transformations & PNG_RGB_TO_GRAY) 1577 png_warning(png_ptr, 1578 "libpng does not support gamma+background+rgb_to_gray"); 1579 1580 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 1581 { 1582 /* We don't get to here unless there is a tRNS chunk with non-opaque 1583 * entries - see the checking code at the start of this function. 1584 */ 1585 png_color back, back_1; 1586 png_colorp palette = png_ptr->palette; 1587 int num_palette = png_ptr->num_palette; 1588 int i; 1589 if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) 1590 { 1591 1592 back.red = png_ptr->gamma_table[png_ptr->background.red]; 1593 back.green = png_ptr->gamma_table[png_ptr->background.green]; 1594 back.blue = png_ptr->gamma_table[png_ptr->background.blue]; 1595 1596 back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; 1597 back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; 1598 back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; 1599 } 1600 else 1601 { 1602 png_fixed_point g, gs; 1603 1604 switch (png_ptr->background_gamma_type) 1605 { 1606 case PNG_BACKGROUND_GAMMA_SCREEN: 1607 g = (png_ptr->screen_gamma); 1608 gs = PNG_FP_1; 1609 break; 1610 1611 case PNG_BACKGROUND_GAMMA_FILE: 1612 g = png_reciprocal(png_ptr->colorspace.gamma); 1613 gs = png_reciprocal2(png_ptr->colorspace.gamma, 1614 png_ptr->screen_gamma); 1615 break; 1616 1617 case PNG_BACKGROUND_GAMMA_UNIQUE: 1618 g = png_reciprocal(png_ptr->background_gamma); 1619 gs = png_reciprocal2(png_ptr->background_gamma, 1620 png_ptr->screen_gamma); 1621 break; 1622 default: 1623 g = PNG_FP_1; /* back_1 */ 1624 gs = PNG_FP_1; /* back */ 1625 break; 1626 } 1627 1628 if (png_gamma_significant(gs)) 1629 { 1630 back.red = png_gamma_8bit_correct(png_ptr->background.red, 1631 gs); 1632 back.green = png_gamma_8bit_correct(png_ptr->background.green, 1633 gs); 1634 back.blue = png_gamma_8bit_correct(png_ptr->background.blue, 1635 gs); 1636 } 1637 1638 else 1639 { 1640 back.red = (png_byte)png_ptr->background.red; 1641 back.green = (png_byte)png_ptr->background.green; 1642 back.blue = (png_byte)png_ptr->background.blue; 1643 } 1644 1645 if (png_gamma_significant(g)) 1646 { 1647 back_1.red = png_gamma_8bit_correct(png_ptr->background.red, 1648 g); 1649 back_1.green = png_gamma_8bit_correct( 1650 png_ptr->background.green, g); 1651 back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue, 1652 g); 1653 } 1654 1655 else 1656 { 1657 back_1.red = (png_byte)png_ptr->background.red; 1658 back_1.green = (png_byte)png_ptr->background.green; 1659 back_1.blue = (png_byte)png_ptr->background.blue; 1660 } 1661 } 1662 1663 for (i = 0; i < num_palette; i++) 1664 { 1665 if (i < (int)png_ptr->num_trans && 1666 png_ptr->trans_alpha[i] != 0xff) 1667 { 1668 if (png_ptr->trans_alpha[i] == 0) 1669 { 1670 palette[i] = back; 1671 } 1672 else /* if (png_ptr->trans_alpha[i] != 0xff) */ 1673 { 1674 png_byte v, w; 1675 1676 v = png_ptr->gamma_to_1[palette[i].red]; 1677 png_composite(w, v, png_ptr->trans_alpha[i], back_1.red); 1678 palette[i].red = png_ptr->gamma_from_1[w]; 1679 1680 v = png_ptr->gamma_to_1[palette[i].green]; 1681 png_composite(w, v, png_ptr->trans_alpha[i], back_1.green); 1682 palette[i].green = png_ptr->gamma_from_1[w]; 1683 1684 v = png_ptr->gamma_to_1[palette[i].blue]; 1685 png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue); 1686 palette[i].blue = png_ptr->gamma_from_1[w]; 1687 } 1688 } 1689 else 1690 { 1691 palette[i].red = png_ptr->gamma_table[palette[i].red]; 1692 palette[i].green = png_ptr->gamma_table[palette[i].green]; 1693 palette[i].blue = png_ptr->gamma_table[palette[i].blue]; 1694 } 1695 } 1696 1697 /* Prevent the transformations being done again. 1698 * 1699 * NOTE: this is highly dubious; it removes the transformations in 1700 * place. This seems inconsistent with the general treatment of the 1701 * transformations elsewhere. 1702 */ 1703 png_ptr->transformations &= ~(PNG_COMPOSE | PNG_GAMMA); 1704 } /* color_type == PNG_COLOR_TYPE_PALETTE */ 1705 1706 /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ 1707 else /* color_type != PNG_COLOR_TYPE_PALETTE */ 1708 { 1709 int gs_sig, g_sig; 1710 png_fixed_point g = PNG_FP_1; /* Correction to linear */ 1711 png_fixed_point gs = PNG_FP_1; /* Correction to screen */ 1712 1713 switch (png_ptr->background_gamma_type) 1714 { 1715 case PNG_BACKGROUND_GAMMA_SCREEN: 1716 g = png_ptr->screen_gamma; 1717 /* gs = PNG_FP_1; */ 1718 break; 1719 1720 case PNG_BACKGROUND_GAMMA_FILE: 1721 g = png_reciprocal(png_ptr->colorspace.gamma); 1722 gs = png_reciprocal2(png_ptr->colorspace.gamma, 1723 png_ptr->screen_gamma); 1724 break; 1725 1726 case PNG_BACKGROUND_GAMMA_UNIQUE: 1727 g = png_reciprocal(png_ptr->background_gamma); 1728 gs = png_reciprocal2(png_ptr->background_gamma, 1729 png_ptr->screen_gamma); 1730 break; 1731 1732 default: 1733 png_error(png_ptr, "invalid background gamma type"); 1734 } 1735 1736 g_sig = png_gamma_significant(g); 1737 gs_sig = png_gamma_significant(gs); 1738 1739 if (g_sig) 1740 png_ptr->background_1.gray = png_gamma_correct(png_ptr, 1741 png_ptr->background.gray, g); 1742 1743 if (gs_sig) 1744 png_ptr->background.gray = png_gamma_correct(png_ptr, 1745 png_ptr->background.gray, gs); 1746 1747 if ((png_ptr->background.red != png_ptr->background.green) || 1748 (png_ptr->background.red != png_ptr->background.blue) || 1749 (png_ptr->background.red != png_ptr->background.gray)) 1750 { 1751 /* RGB or RGBA with color background */ 1752 if (g_sig) 1753 { 1754 png_ptr->background_1.red = png_gamma_correct(png_ptr, 1755 png_ptr->background.red, g); 1756 1757 png_ptr->background_1.green = png_gamma_correct(png_ptr, 1758 png_ptr->background.green, g); 1759 1760 png_ptr->background_1.blue = png_gamma_correct(png_ptr, 1761 png_ptr->background.blue, g); 1762 } 1763 1764 if (gs_sig) 1765 { 1766 png_ptr->background.red = png_gamma_correct(png_ptr, 1767 png_ptr->background.red, gs); 1768 1769 png_ptr->background.green = png_gamma_correct(png_ptr, 1770 png_ptr->background.green, gs); 1771 1772 png_ptr->background.blue = png_gamma_correct(png_ptr, 1773 png_ptr->background.blue, gs); 1774 } 1775 } 1776 1777 else 1778 { 1779 /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */ 1780 png_ptr->background_1.red = png_ptr->background_1.green 1781 = png_ptr->background_1.blue = png_ptr->background_1.gray; 1782 1783 png_ptr->background.red = png_ptr->background.green 1784 = png_ptr->background.blue = png_ptr->background.gray; 1785 } 1786 1787 /* The background is now in screen gamma: */ 1788 png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_SCREEN; 1789 } /* color_type != PNG_COLOR_TYPE_PALETTE */ 1790 }/* png_ptr->transformations & PNG_BACKGROUND */ 1791 1792 else 1793 /* Transformation does not include PNG_BACKGROUND */ 1794 #endif /* PNG_READ_BACKGROUND_SUPPORTED */ 1795 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE 1796 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 1797 /* RGB_TO_GRAY needs to have non-gamma-corrected values! */ 1798 && ((png_ptr->transformations & PNG_EXPAND) == 0 || 1799 (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0) 1800 #endif 1801 ) 1802 { 1803 png_colorp palette = png_ptr->palette; 1804 int num_palette = png_ptr->num_palette; 1805 int i; 1806 1807 /* NOTE: there are other transformations that should probably be in 1808 * here too. 1809 */ 1810 for (i = 0; i < num_palette; i++) 1811 { 1812 palette[i].red = png_ptr->gamma_table[palette[i].red]; 1813 palette[i].green = png_ptr->gamma_table[palette[i].green]; 1814 palette[i].blue = png_ptr->gamma_table[palette[i].blue]; 1815 } 1816 1817 /* Done the gamma correction. */ 1818 png_ptr->transformations &= ~PNG_GAMMA; 1819 } /* color_type == PALETTE && !PNG_BACKGROUND transformation */ 1820 } 1821 #ifdef PNG_READ_BACKGROUND_SUPPORTED 1822 else 1823 #endif 1824 #endif /* PNG_READ_GAMMA_SUPPORTED */ 1825 1826 #ifdef PNG_READ_BACKGROUND_SUPPORTED 1827 /* No GAMMA transformation (see the hanging else 4 lines above) */ 1828 if ((png_ptr->transformations & PNG_COMPOSE) && 1829 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) 1830 { 1831 int i; 1832 int istop = (int)png_ptr->num_trans; 1833 png_color back; 1834 png_colorp palette = png_ptr->palette; 1835 1836 back.red = (png_byte)png_ptr->background.red; 1837 back.green = (png_byte)png_ptr->background.green; 1838 back.blue = (png_byte)png_ptr->background.blue; 1839 1840 for (i = 0; i < istop; i++) 1841 { 1842 if (png_ptr->trans_alpha[i] == 0) 1843 { 1844 palette[i] = back; 1845 } 1846 1847 else if (png_ptr->trans_alpha[i] != 0xff) 1848 { 1849 /* The png_composite() macro is defined in png.h */ 1850 png_composite(palette[i].red, palette[i].red, 1851 png_ptr->trans_alpha[i], back.red); 1852 1853 png_composite(palette[i].green, palette[i].green, 1854 png_ptr->trans_alpha[i], back.green); 1855 1856 png_composite(palette[i].blue, palette[i].blue, 1857 png_ptr->trans_alpha[i], back.blue); 1858 } 1859 } 1860 1861 png_ptr->transformations &= ~PNG_COMPOSE; 1862 1863 //png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; /* Add by Sunliang.Liu */ 1864 } 1865 #endif /* PNG_READ_BACKGROUND_SUPPORTED */ 1866 1867 #ifdef PNG_READ_SHIFT_SUPPORTED 1868 if ((png_ptr->transformations & PNG_SHIFT) && 1869 !(png_ptr->transformations & PNG_EXPAND) && 1870 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) 1871 { 1872 int i; 1873 int istop = png_ptr->num_palette; 1874 int shift = 8 - png_ptr->sig_bit.red; 1875 1876 png_ptr->transformations &= ~PNG_SHIFT; 1877 1878 /* significant bits can be in the range 1 to 7 for a meaninful result, if 1879 * the number of significant bits is 0 then no shift is done (this is an 1880 * error condition which is silently ignored.) 1881 */ 1882 if (shift > 0 && shift < 8) for (i=0; i<istop; ++i) 1883 { 1884 int component = png_ptr->palette[i].red; 1885 1886 component >>= shift; 1887 png_ptr->palette[i].red = (png_byte)component; 1888 } 1889 1890 shift = 8 - png_ptr->sig_bit.green; 1891 if (shift > 0 && shift < 8) for (i=0; i<istop; ++i) 1892 { 1893 int component = png_ptr->palette[i].green; 1894 1895 component >>= shift; 1896 png_ptr->palette[i].green = (png_byte)component; 1897 } 1898 1899 shift = 8 - png_ptr->sig_bit.blue; 1900 if (shift > 0 && shift < 8) for (i=0; i<istop; ++i) 1901 { 1902 int component = png_ptr->palette[i].blue; 1903 1904 component >>= shift; 1905 png_ptr->palette[i].blue = (png_byte)component; 1906 } 1907 } 1908 #endif /* PNG_READ_SHIFT_SUPPORTED */ 1909 } 1910 1911 /* Modify the info structure to reflect the transformations. The 1912 * info should be updated so a PNG file could be written with it, 1913 * assuming the transformations result in valid PNG data. 1914 */ 1915 void /* PRIVATE */ 1916 png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr) 1917 { 1918 png_debug(1, "in png_read_transform_info"); 1919 1920 #ifdef PNG_READ_EXPAND_SUPPORTED 1921 if (png_ptr->transformations & PNG_EXPAND) 1922 { 1923 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 1924 { 1925 /* This check must match what actually happens in 1926 * png_do_expand_palette; if it ever checks the tRNS chunk to see if 1927 * it is all opaque we must do the same (at present it does not.) 1928 */ 1929 if (png_ptr->num_trans > 0) 1930 info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; 1931 1932 else 1933 info_ptr->color_type = PNG_COLOR_TYPE_RGB; 1934 1935 info_ptr->bit_depth = 8; 1936 info_ptr->num_trans = 0; 1937 } 1938 else 1939 { 1940 if (png_ptr->num_trans) 1941 { 1942 if (png_ptr->transformations & PNG_EXPAND_tRNS) 1943 info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; 1944 } 1945 if (info_ptr->bit_depth < 8) 1946 info_ptr->bit_depth = 8; 1947 1948 info_ptr->num_trans = 0; 1949 } 1950 } 1951 #endif 1952 1953 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ 1954 defined(PNG_READ_ALPHA_MODE_SUPPORTED) 1955 /* The following is almost certainly wrong unless the background value is in 1956 * the screen space! 1957 */ 1958 if (png_ptr->transformations & PNG_COMPOSE) 1959 info_ptr->background = png_ptr->background; 1960 #endif 1961 1962 #ifdef PNG_READ_GAMMA_SUPPORTED 1963 /* The following used to be conditional on PNG_GAMMA (prior to 1.5.4), 1964 * however it seems that the code in png_init_read_transformations, which has 1965 * been called before this from png_read_update_info->png_read_start_row 1966 * sometimes does the gamma transform and cancels the flag. 1967 * 1968 * TODO: this looks wrong; the info_ptr should end up with a gamma equal to 1969 * the screen_gamma value. The following probably results in weirdness if 1970 * the info_ptr is used by the app after the rows have been read. 1971 */ 1972 info_ptr->colorspace.gamma = png_ptr->colorspace.gamma; 1973 #endif 1974 1975 if (info_ptr->bit_depth == 16) 1976 { 1977 # ifdef PNG_READ_16BIT_SUPPORTED 1978 # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED 1979 if (png_ptr->transformations & PNG_SCALE_16_TO_8) 1980 info_ptr->bit_depth = 8; 1981 # endif 1982 1983 # ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED 1984 if (png_ptr->transformations & PNG_16_TO_8) 1985 info_ptr->bit_depth = 8; 1986 # endif 1987 1988 # else 1989 /* No 16 bit support: force chopping 16-bit input down to 8, in this case 1990 * the app program can chose if both APIs are available by setting the 1991 * correct scaling to use. 1992 */ 1993 # ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED 1994 /* For compatibility with previous versions use the strip method by 1995 * default. This code works because if PNG_SCALE_16_TO_8 is already 1996 * set the code below will do that in preference to the chop. 1997 */ 1998 png_ptr->transformations |= PNG_16_TO_8; 1999 info_ptr->bit_depth = 8; 2000 # else 2001 2002 # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED 2003 png_ptr->transformations |= PNG_SCALE_16_TO_8; 2004 info_ptr->bit_depth = 8; 2005 # else 2006 2007 CONFIGURATION ERROR: you must enable at least one 16 to 8 method 2008 # endif 2009 # endif 2010 #endif /* !READ_16BIT_SUPPORTED */ 2011 } 2012 2013 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 2014 if (png_ptr->transformations & PNG_GRAY_TO_RGB) 2015 info_ptr->color_type = (png_byte)(info_ptr->color_type | 2016 PNG_COLOR_MASK_COLOR); 2017 #endif 2018 2019 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 2020 if (png_ptr->transformations & PNG_RGB_TO_GRAY) 2021 info_ptr->color_type = (png_byte)(info_ptr->color_type & 2022 ~PNG_COLOR_MASK_COLOR); 2023 #endif 2024 2025 #ifdef PNG_READ_QUANTIZE_SUPPORTED 2026 if (png_ptr->transformations & PNG_QUANTIZE) 2027 { 2028 if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || 2029 (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && 2030 png_ptr->palette_lookup && info_ptr->bit_depth == 8) 2031 { 2032 info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; 2033 } 2034 } 2035 #endif 2036 2037 #ifdef PNG_READ_EXPAND_16_SUPPORTED 2038 if (png_ptr->transformations & PNG_EXPAND_16 && info_ptr->bit_depth == 8 && 2039 info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) 2040 { 2041 info_ptr->bit_depth = 16; 2042 } 2043 #endif 2044 2045 #ifdef PNG_READ_PACK_SUPPORTED 2046 if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) 2047 info_ptr->bit_depth = 8; 2048 #endif 2049 2050 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 2051 info_ptr->channels = 1; 2052 2053 else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) 2054 info_ptr->channels = 3; 2055 2056 else 2057 info_ptr->channels = 1; 2058 2059 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 2060 if (png_ptr->transformations & PNG_STRIP_ALPHA) 2061 { 2062 info_ptr->color_type = (png_byte)(info_ptr->color_type & 2063 ~PNG_COLOR_MASK_ALPHA); 2064 info_ptr->num_trans = 0; 2065 } 2066 #endif 2067 2068 if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) 2069 info_ptr->channels++; 2070 2071 #ifdef PNG_READ_FILLER_SUPPORTED 2072 /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */ 2073 if ((png_ptr->transformations & PNG_FILLER) && 2074 ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || 2075 (info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) 2076 { 2077 info_ptr->channels++; 2078 /* If adding a true alpha channel not just filler */ 2079 if (png_ptr->transformations & PNG_ADD_ALPHA) 2080 info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; 2081 } 2082 #endif 2083 2084 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \ 2085 defined(PNG_READ_USER_TRANSFORM_SUPPORTED) 2086 if (png_ptr->transformations & PNG_USER_TRANSFORM) 2087 { 2088 if (info_ptr->bit_depth < png_ptr->user_transform_depth) 2089 info_ptr->bit_depth = png_ptr->user_transform_depth; 2090 2091 if (info_ptr->channels < png_ptr->user_transform_channels) 2092 info_ptr->channels = png_ptr->user_transform_channels; 2093 } 2094 #endif 2095 2096 info_ptr->pixel_depth = (png_byte)(info_ptr->channels * 2097 info_ptr->bit_depth); 2098 2099 info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width); 2100 2101 /* Adding in 1.5.4: cache the above value in png_struct so that we can later 2102 * check in png_rowbytes that the user buffer won't get overwritten. Note 2103 * that the field is not always set - if png_read_update_info isn't called 2104 * the application has to either not do any transforms or get the calculation 2105 * right itself. 2106 */ 2107 png_ptr->info_rowbytes = info_ptr->rowbytes; 2108 2109 #ifndef PNG_READ_EXPAND_SUPPORTED 2110 if (png_ptr) 2111 return; 2112 #endif 2113 } 2114 2115 /* Transform the row. The order of transformations is significant, 2116 * and is very touchy. If you add a transformation, take care to 2117 * decide how it fits in with the other transformations here. 2118 */ 2119 void /* PRIVATE */ 2120 png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info) 2121 { 2122 png_debug(1, "in png_do_read_transformations"); 2123 2124 if (png_ptr->row_buf == NULL) 2125 { 2126 /* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this 2127 * error is incredibly rare and incredibly easy to debug without this 2128 * information. 2129 */ 2130 png_error(png_ptr, "NULL row buffer"); 2131 } 2132 2133 /* The following is debugging; prior to 1.5.4 the code was never compiled in; 2134 * in 1.5.4 PNG_FLAG_DETECT_UNINITIALIZED was added and the macro 2135 * PNG_WARN_UNINITIALIZED_ROW removed. In 1.6 the new flag is set only for 2136 * all transformations, however in practice the ROW_INIT always gets done on 2137 * demand, if necessary. 2138 */ 2139 if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 && 2140 !(png_ptr->flags & PNG_FLAG_ROW_INIT)) 2141 { 2142 /* Application has failed to call either png_read_start_image() or 2143 * png_read_update_info() after setting transforms that expand pixels. 2144 * This check added to libpng-1.2.19 (but not enabled until 1.5.4). 2145 */ 2146 png_error(png_ptr, "Uninitialized row"); 2147 } 2148 2149 #ifdef PNG_READ_EXPAND_SUPPORTED 2150 if (png_ptr->transformations & PNG_EXPAND) 2151 { 2152 if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) 2153 { 2154 png_do_expand_palette(row_info, png_ptr->row_buf + 1, 2155 png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans); 2156 } 2157 2158 else 2159 { 2160 if (png_ptr->num_trans && 2161 (png_ptr->transformations & PNG_EXPAND_tRNS)) 2162 png_do_expand(row_info, png_ptr->row_buf + 1, 2163 &(png_ptr->trans_color)); 2164 2165 else 2166 png_do_expand(row_info, png_ptr->row_buf + 1, 2167 NULL); 2168 } 2169 } 2170 #endif 2171 2172 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 2173 if ((png_ptr->transformations & PNG_STRIP_ALPHA) && 2174 !(png_ptr->transformations & PNG_COMPOSE) && 2175 (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || 2176 row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) 2177 png_do_strip_channel(row_info, png_ptr->row_buf + 1, 2178 0 /* at_start == false, because SWAP_ALPHA happens later */); 2179 #endif 2180 2181 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 2182 if (png_ptr->transformations & PNG_RGB_TO_GRAY) 2183 { 2184 int rgb_error = 2185 png_do_rgb_to_gray(png_ptr, row_info, 2186 png_ptr->row_buf + 1); 2187 2188 if (rgb_error) 2189 { 2190 png_ptr->rgb_to_gray_status=1; 2191 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 2192 PNG_RGB_TO_GRAY_WARN) 2193 png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel"); 2194 2195 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 2196 PNG_RGB_TO_GRAY_ERR) 2197 png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel"); 2198 } 2199 } 2200 #endif 2201 2202 /* From Andreas Dilger e-mail to png-implement, 26 March 1998: 2203 * 2204 * In most cases, the "simple transparency" should be done prior to doing 2205 * gray-to-RGB, or you will have to test 3x as many bytes to check if a 2206 * pixel is transparent. You would also need to make sure that the 2207 * transparency information is upgraded to RGB. 2208 * 2209 * To summarize, the current flow is: 2210 * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite 2211 * with background "in place" if transparent, 2212 * convert to RGB if necessary 2213 * - Gray + alpha -> composite with gray background and remove alpha bytes, 2214 * convert to RGB if necessary 2215 * 2216 * To support RGB backgrounds for gray images we need: 2217 * - Gray + simple transparency -> convert to RGB + simple transparency, 2218 * compare 3 or 6 bytes and composite with 2219 * background "in place" if transparent 2220 * (3x compare/pixel compared to doing 2221 * composite with gray bkgrnd) 2222 * - Gray + alpha -> convert to RGB + alpha, composite with background and 2223 * remove alpha bytes (3x float 2224 * operations/pixel compared with composite 2225 * on gray background) 2226 * 2227 * Greg's change will do this. The reason it wasn't done before is for 2228 * performance, as this increases the per-pixel operations. If we would check 2229 * in advance if the background was gray or RGB, and position the gray-to-RGB 2230 * transform appropriately, then it would save a lot of work/time. 2231 */ 2232 2233 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 2234 /* If gray -> RGB, do so now only if background is non-gray; else do later 2235 * for performance reasons 2236 */ 2237 if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && 2238 !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) 2239 png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); 2240 #endif 2241 2242 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ 2243 defined(PNG_READ_ALPHA_MODE_SUPPORTED) 2244 if (png_ptr->transformations & PNG_COMPOSE) 2245 png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr); 2246 #endif 2247 2248 #ifdef PNG_READ_GAMMA_SUPPORTED 2249 if ((png_ptr->transformations & PNG_GAMMA) && 2250 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 2251 /* Because RGB_TO_GRAY does the gamma transform. */ 2252 !(png_ptr->transformations & PNG_RGB_TO_GRAY) && 2253 #endif 2254 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ 2255 defined(PNG_READ_ALPHA_MODE_SUPPORTED) 2256 /* Because PNG_COMPOSE does the gamma transform if there is something to 2257 * do (if there is an alpha channel or transparency.) 2258 */ 2259 !((png_ptr->transformations & PNG_COMPOSE) && 2260 ((png_ptr->num_trans != 0) || 2261 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && 2262 #endif 2263 /* Because png_init_read_transformations transforms the palette, unless 2264 * RGB_TO_GRAY will do the transform. 2265 */ 2266 (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) 2267 png_do_gamma(row_info, png_ptr->row_buf + 1, png_ptr); 2268 #endif 2269 2270 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 2271 if ((png_ptr->transformations & PNG_STRIP_ALPHA) && 2272 (png_ptr->transformations & PNG_COMPOSE) && 2273 (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || 2274 row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) 2275 png_do_strip_channel(row_info, png_ptr->row_buf + 1, 2276 0 /* at_start == false, because SWAP_ALPHA happens later */); 2277 #endif 2278 2279 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED 2280 if ((png_ptr->transformations & PNG_ENCODE_ALPHA) && 2281 (row_info->color_type & PNG_COLOR_MASK_ALPHA)) 2282 png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr); 2283 #endif 2284 2285 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED 2286 if (png_ptr->transformations & PNG_SCALE_16_TO_8) 2287 png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1); 2288 #endif 2289 2290 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED 2291 /* There is no harm in doing both of these because only one has any effect, 2292 * by putting the 'scale' option first if the app asks for scale (either by 2293 * calling the API or in a TRANSFORM flag) this is what happens. 2294 */ 2295 if (png_ptr->transformations & PNG_16_TO_8) 2296 png_do_chop(row_info, png_ptr->row_buf + 1); 2297 #endif 2298 2299 #ifdef PNG_READ_QUANTIZE_SUPPORTED 2300 if (png_ptr->transformations & PNG_QUANTIZE) 2301 { 2302 png_do_quantize(row_info, png_ptr->row_buf + 1, 2303 png_ptr->palette_lookup, png_ptr->quantize_index); 2304 2305 if (row_info->rowbytes == 0) 2306 png_error(png_ptr, "png_do_quantize returned rowbytes=0"); 2307 } 2308 #endif /* PNG_READ_QUANTIZE_SUPPORTED */ 2309 2310 #ifdef PNG_READ_EXPAND_16_SUPPORTED 2311 /* Do the expansion now, after all the arithmetic has been done. Notice 2312 * that previous transformations can handle the PNG_EXPAND_16 flag if this 2313 * is efficient (particularly true in the case of gamma correction, where 2314 * better accuracy results faster!) 2315 */ 2316 if (png_ptr->transformations & PNG_EXPAND_16) 2317 png_do_expand_16(row_info, png_ptr->row_buf + 1); 2318 #endif 2319 2320 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 2321 /* NOTE: moved here in 1.5.4 (from much later in this list.) */ 2322 if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && 2323 (png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) 2324 png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); 2325 #endif 2326 2327 #ifdef PNG_READ_INVERT_SUPPORTED 2328 if (png_ptr->transformations & PNG_INVERT_MONO) 2329 png_do_invert(row_info, png_ptr->row_buf + 1); 2330 #endif 2331 2332 #ifdef PNG_READ_SHIFT_SUPPORTED 2333 if (png_ptr->transformations & PNG_SHIFT) 2334 png_do_unshift(row_info, png_ptr->row_buf + 1, 2335 &(png_ptr->shift)); 2336 #endif 2337 2338 #ifdef PNG_READ_PACK_SUPPORTED 2339 if (png_ptr->transformations & PNG_PACK) 2340 png_do_unpack(row_info, png_ptr->row_buf + 1); 2341 #endif 2342 2343 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED 2344 /* Added at libpng-1.5.10 */ 2345 if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && 2346 png_ptr->num_palette_max >= 0) 2347 png_do_check_palette_indexes(png_ptr, row_info); 2348 #endif 2349 2350 #ifdef PNG_READ_BGR_SUPPORTED 2351 if (png_ptr->transformations & PNG_BGR) 2352 png_do_bgr(row_info, png_ptr->row_buf + 1); 2353 #endif 2354 2355 #ifdef PNG_READ_PACKSWAP_SUPPORTED 2356 if (png_ptr->transformations & PNG_PACKSWAP) 2357 png_do_packswap(row_info, png_ptr->row_buf + 1); 2358 #endif 2359 2360 #ifdef PNG_READ_FILLER_SUPPORTED 2361 if (png_ptr->transformations & PNG_FILLER) 2362 png_do_read_filler(row_info, png_ptr->row_buf + 1, 2363 (png_uint_32)png_ptr->filler, png_ptr->flags); 2364 #endif 2365 2366 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED 2367 if (png_ptr->transformations & PNG_INVERT_ALPHA) 2368 png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1); 2369 #endif 2370 2371 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED 2372 if (png_ptr->transformations & PNG_SWAP_ALPHA) 2373 png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1); 2374 #endif 2375 2376 #ifdef PNG_READ_16BIT_SUPPORTED 2377 #ifdef PNG_READ_SWAP_SUPPORTED 2378 if (png_ptr->transformations & PNG_SWAP_BYTES) 2379 png_do_swap(row_info, png_ptr->row_buf + 1); 2380 #endif 2381 #endif 2382 2383 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED 2384 if (png_ptr->transformations & PNG_USER_TRANSFORM) 2385 { 2386 if (png_ptr->read_user_transform_fn != NULL) 2387 (*(png_ptr->read_user_transform_fn)) /* User read transform function */ 2388 (png_ptr, /* png_ptr */ 2389 row_info, /* row_info: */ 2390 /* png_uint_32 width; width of row */ 2391 /* png_size_t rowbytes; number of bytes in row */ 2392 /* png_byte color_type; color type of pixels */ 2393 /* png_byte bit_depth; bit depth of samples */ 2394 /* png_byte channels; number of channels (1-4) */ 2395 /* png_byte pixel_depth; bits per pixel (depth*channels) */ 2396 png_ptr->row_buf + 1); /* start of pixel data for row */ 2397 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED 2398 if (png_ptr->user_transform_depth) 2399 row_info->bit_depth = png_ptr->user_transform_depth; 2400 2401 if (png_ptr->user_transform_channels) 2402 row_info->channels = png_ptr->user_transform_channels; 2403 #endif 2404 row_info->pixel_depth = (png_byte)(row_info->bit_depth * 2405 row_info->channels); 2406 2407 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->width); 2408 } 2409 #endif 2410 } 2411 2412 #ifdef PNG_READ_PACK_SUPPORTED 2413 /* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, 2414 * without changing the actual values. Thus, if you had a row with 2415 * a bit depth of 1, you would end up with bytes that only contained 2416 * the numbers 0 or 1. If you would rather they contain 0 and 255, use 2417 * png_do_shift() after this. 2418 */ 2419 void /* PRIVATE */ 2420 png_do_unpack(png_row_infop row_info, png_bytep row) 2421 { 2422 png_debug(1, "in png_do_unpack"); 2423 2424 if (row_info->bit_depth < 8) 2425 { 2426 png_uint_32 i; 2427 png_uint_32 row_width=row_info->width; 2428 2429 switch (row_info->bit_depth) 2430 { 2431 case 1: 2432 { 2433 png_bytep sp = row + (png_size_t)((row_width - 1) >> 3); 2434 png_bytep dp = row + (png_size_t)row_width - 1; 2435 png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07); 2436 for (i = 0; i < row_width; i++) 2437 { 2438 *dp = (png_byte)((*sp >> shift) & 0x01); 2439 2440 if (shift == 7) 2441 { 2442 shift = 0; 2443 sp--; 2444 } 2445 2446 else 2447 shift++; 2448 2449 dp--; 2450 } 2451 break; 2452 } 2453 2454 case 2: 2455 { 2456 2457 png_bytep sp = row + (png_size_t)((row_width - 1) >> 2); 2458 png_bytep dp = row + (png_size_t)row_width - 1; 2459 png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); 2460 for (i = 0; i < row_width; i++) 2461 { 2462 *dp = (png_byte)((*sp >> shift) & 0x03); 2463 2464 if (shift == 6) 2465 { 2466 shift = 0; 2467 sp--; 2468 } 2469 2470 else 2471 shift += 2; 2472 2473 dp--; 2474 } 2475 break; 2476 } 2477 2478 case 4: 2479 { 2480 png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); 2481 png_bytep dp = row + (png_size_t)row_width - 1; 2482 png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); 2483 for (i = 0; i < row_width; i++) 2484 { 2485 *dp = (png_byte)((*sp >> shift) & 0x0f); 2486 2487 if (shift == 4) 2488 { 2489 shift = 0; 2490 sp--; 2491 } 2492 2493 else 2494 shift = 4; 2495 2496 dp--; 2497 } 2498 break; 2499 } 2500 2501 default: 2502 break; 2503 } 2504 row_info->bit_depth = 8; 2505 row_info->pixel_depth = (png_byte)(8 * row_info->channels); 2506 row_info->rowbytes = row_width * row_info->channels; 2507 } 2508 } 2509 #endif 2510 2511 #ifdef PNG_READ_SHIFT_SUPPORTED 2512 /* Reverse the effects of png_do_shift. This routine merely shifts the 2513 * pixels back to their significant bits values. Thus, if you have 2514 * a row of bit depth 8, but only 5 are significant, this will shift 2515 * the values back to 0 through 31. 2516 */ 2517 void /* PRIVATE */ 2518 png_do_unshift(png_row_infop row_info, png_bytep row, 2519 png_const_color_8p sig_bits) 2520 { 2521 int color_type; 2522 2523 png_debug(1, "in png_do_unshift"); 2524 2525 /* The palette case has already been handled in the _init routine. */ 2526 color_type = row_info->color_type; 2527 2528 if (color_type != PNG_COLOR_TYPE_PALETTE) 2529 { 2530 int shift[4]; 2531 int channels = 0; 2532 int bit_depth = row_info->bit_depth; 2533 2534 if (color_type & PNG_COLOR_MASK_COLOR) 2535 { 2536 shift[channels++] = bit_depth - sig_bits->red; 2537 shift[channels++] = bit_depth - sig_bits->green; 2538 shift[channels++] = bit_depth - sig_bits->blue; 2539 } 2540 2541 else 2542 { 2543 shift[channels++] = bit_depth - sig_bits->gray; 2544 } 2545 2546 if (color_type & PNG_COLOR_MASK_ALPHA) 2547 { 2548 shift[channels++] = bit_depth - sig_bits->alpha; 2549 } 2550 2551 { 2552 int c, have_shift; 2553 2554 for (c = have_shift = 0; c < channels; ++c) 2555 { 2556 /* A shift of more than the bit depth is an error condition but it 2557 * gets ignored here. 2558 */ 2559 if (shift[c] <= 0 || shift[c] >= bit_depth) 2560 shift[c] = 0; 2561 2562 else 2563 have_shift = 1; 2564 } 2565 2566 if (!have_shift) 2567 return; 2568 } 2569 2570 switch (bit_depth) 2571 { 2572 default: 2573 /* Must be 1bpp gray: should not be here! */ 2574 /* NOTREACHED */ 2575 break; 2576 2577 case 2: 2578 /* Must be 2bpp gray */ 2579 /* assert(channels == 1 && shift[0] == 1) */ 2580 { 2581 png_bytep bp = row; 2582 png_bytep bp_end = bp + row_info->rowbytes; 2583 2584 while (bp < bp_end) 2585 { 2586 int b = (*bp >> 1) & 0x55; 2587 *bp++ = (png_byte)b; 2588 } 2589 break; 2590 } 2591 2592 case 4: 2593 /* Must be 4bpp gray */ 2594 /* assert(channels == 1) */ 2595 { 2596 png_bytep bp = row; 2597 png_bytep bp_end = bp + row_info->rowbytes; 2598 int gray_shift = shift[0]; 2599 int mask = 0xf >> gray_shift; 2600 2601 mask |= mask << 4; 2602 2603 while (bp < bp_end) 2604 { 2605 int b = (*bp >> gray_shift) & mask; 2606 *bp++ = (png_byte)b; 2607 } 2608 break; 2609 } 2610 2611 case 8: 2612 /* Single byte components, G, GA, RGB, RGBA */ 2613 { 2614 png_bytep bp = row; 2615 png_bytep bp_end = bp + row_info->rowbytes; 2616 int channel = 0; 2617 2618 while (bp < bp_end) 2619 { 2620 int b = *bp >> shift[channel]; 2621 if (++channel >= channels) 2622 channel = 0; 2623 *bp++ = (png_byte)b; 2624 } 2625 break; 2626 } 2627 2628 #ifdef PNG_READ_16BIT_SUPPORTED 2629 case 16: 2630 /* Double byte components, G, GA, RGB, RGBA */ 2631 { 2632 png_bytep bp = row; 2633 png_bytep bp_end = bp + row_info->rowbytes; 2634 int channel = 0; 2635 2636 while (bp < bp_end) 2637 { 2638 int value = (bp[0] << 8) + bp[1]; 2639 2640 value >>= shift[channel]; 2641 if (++channel >= channels) 2642 channel = 0; 2643 *bp++ = (png_byte)(value >> 8); 2644 *bp++ = (png_byte)(value & 0xff); 2645 } 2646 break; 2647 } 2648 #endif 2649 } 2650 } 2651 } 2652 #endif 2653 2654 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED 2655 /* Scale rows of bit depth 16 down to 8 accurately */ 2656 void /* PRIVATE */ 2657 png_do_scale_16_to_8(png_row_infop row_info, png_bytep row) 2658 { 2659 png_debug(1, "in png_do_scale_16_to_8"); 2660 2661 if (row_info->bit_depth == 16) 2662 { 2663 png_bytep sp = row; /* source */ 2664 png_bytep dp = row; /* destination */ 2665 png_bytep ep = sp + row_info->rowbytes; /* end+1 */ 2666 2667 while (sp < ep) 2668 { 2669 /* The input is an array of 16 bit components, these must be scaled to 2670 * 8 bits each. For a 16 bit value V the required value (from the PNG 2671 * specification) is: 2672 * 2673 * (V * 255) / 65535 2674 * 2675 * This reduces to round(V / 257), or floor((V + 128.5)/257) 2676 * 2677 * Represent V as the two byte value vhi.vlo. Make a guess that the 2678 * result is the top byte of V, vhi, then the correction to this value 2679 * is: 2680 * 2681 * error = floor(((V-vhi.vhi) + 128.5) / 257) 2682 * = floor(((vlo-vhi) + 128.5) / 257) 2683 * 2684 * This can be approximated using integer arithmetic (and a signed 2685 * shift): 2686 * 2687 * error = (vlo-vhi+128) >> 8; 2688 * 2689 * The approximate differs from the exact answer only when (vlo-vhi) is 2690 * 128; it then gives a correction of +1 when the exact correction is 2691 * 0. This gives 128 errors. The exact answer (correct for all 16 bit 2692 * input values) is: 2693 * 2694 * error = (vlo-vhi+128)*65535 >> 24; 2695 * 2696 * An alternative arithmetic calculation which also gives no errors is: 2697 * 2698 * (V * 255 + 32895) >> 16 2699 */ 2700 2701 png_int_32 tmp = *sp++; /* must be signed! */ 2702 tmp += (((int)*sp++ - tmp + 128) * 65535) >> 24; 2703 *dp++ = (png_byte)tmp; 2704 } 2705 2706 row_info->bit_depth = 8; 2707 row_info->pixel_depth = (png_byte)(8 * row_info->channels); 2708 row_info->rowbytes = row_info->width * row_info->channels; 2709 } 2710 } 2711 #endif 2712 2713 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED 2714 void /* PRIVATE */ 2715 /* Simply discard the low byte. This was the default behavior prior 2716 * to libpng-1.5.4. 2717 */ 2718 png_do_chop(png_row_infop row_info, png_bytep row) 2719 { 2720 png_debug(1, "in png_do_chop"); 2721 2722 if (row_info->bit_depth == 16) 2723 { 2724 png_bytep sp = row; /* source */ 2725 png_bytep dp = row; /* destination */ 2726 png_bytep ep = sp + row_info->rowbytes; /* end+1 */ 2727 2728 while (sp < ep) 2729 { 2730 *dp++ = *sp; 2731 sp += 2; /* skip low byte */ 2732 } 2733 2734 row_info->bit_depth = 8; 2735 row_info->pixel_depth = (png_byte)(8 * row_info->channels); 2736 row_info->rowbytes = row_info->width * row_info->channels; 2737 } 2738 } 2739 #endif 2740 2741 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED 2742 void /* PRIVATE */ 2743 png_do_read_swap_alpha(png_row_infop row_info, png_bytep row) 2744 { 2745 png_debug(1, "in png_do_read_swap_alpha"); 2746 2747 { 2748 png_uint_32 row_width = row_info->width; 2749 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 2750 { 2751 /* This converts from RGBA to ARGB */ 2752 if (row_info->bit_depth == 8) 2753 { 2754 png_bytep sp = row + row_info->rowbytes; 2755 png_bytep dp = sp; 2756 png_byte save; 2757 png_uint_32 i; 2758 2759 for (i = 0; i < row_width; i++) 2760 { 2761 save = *(--sp); 2762 *(--dp) = *(--sp); 2763 *(--dp) = *(--sp); 2764 *(--dp) = *(--sp); 2765 *(--dp) = save; 2766 } 2767 } 2768 2769 #ifdef PNG_READ_16BIT_SUPPORTED 2770 /* This converts from RRGGBBAA to AARRGGBB */ 2771 else 2772 { 2773 png_bytep sp = row + row_info->rowbytes; 2774 png_bytep dp = sp; 2775 png_byte save[2]; 2776 png_uint_32 i; 2777 2778 for (i = 0; i < row_width; i++) 2779 { 2780 save[0] = *(--sp); 2781 save[1] = *(--sp); 2782 *(--dp) = *(--sp); 2783 *(--dp) = *(--sp); 2784 *(--dp) = *(--sp); 2785 *(--dp) = *(--sp); 2786 *(--dp) = *(--sp); 2787 *(--dp) = *(--sp); 2788 *(--dp) = save[0]; 2789 *(--dp) = save[1]; 2790 } 2791 } 2792 #endif 2793 } 2794 2795 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) 2796 { 2797 /* This converts from GA to AG */ 2798 if (row_info->bit_depth == 8) 2799 { 2800 png_bytep sp = row + row_info->rowbytes; 2801 png_bytep dp = sp; 2802 png_byte save; 2803 png_uint_32 i; 2804 2805 for (i = 0; i < row_width; i++) 2806 { 2807 save = *(--sp); 2808 *(--dp) = *(--sp); 2809 *(--dp) = save; 2810 } 2811 } 2812 2813 #ifdef PNG_READ_16BIT_SUPPORTED 2814 /* This converts from GGAA to AAGG */ 2815 else 2816 { 2817 png_bytep sp = row + row_info->rowbytes; 2818 png_bytep dp = sp; 2819 png_byte save[2]; 2820 png_uint_32 i; 2821 2822 for (i = 0; i < row_width; i++) 2823 { 2824 save[0] = *(--sp); 2825 save[1] = *(--sp); 2826 *(--dp) = *(--sp); 2827 *(--dp) = *(--sp); 2828 *(--dp) = save[0]; 2829 *(--dp) = save[1]; 2830 } 2831 } 2832 #endif 2833 } 2834 } 2835 } 2836 #endif 2837 2838 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED 2839 void /* PRIVATE */ 2840 png_do_read_invert_alpha(png_row_infop row_info, png_bytep row) 2841 { 2842 png_uint_32 row_width; 2843 png_debug(1, "in png_do_read_invert_alpha"); 2844 2845 row_width = row_info->width; 2846 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 2847 { 2848 if (row_info->bit_depth == 8) 2849 { 2850 /* This inverts the alpha channel in RGBA */ 2851 png_bytep sp = row + row_info->rowbytes; 2852 png_bytep dp = sp; 2853 png_uint_32 i; 2854 2855 for (i = 0; i < row_width; i++) 2856 { 2857 *(--dp) = (png_byte)(255 - *(--sp)); 2858 2859 /* This does nothing: 2860 *(--dp) = *(--sp); 2861 *(--dp) = *(--sp); 2862 *(--dp) = *(--sp); 2863 We can replace it with: 2864 */ 2865 sp-=3; 2866 dp=sp; 2867 } 2868 } 2869 2870 #ifdef PNG_READ_16BIT_SUPPORTED 2871 /* This inverts the alpha channel in RRGGBBAA */ 2872 else 2873 { 2874 png_bytep sp = row + row_info->rowbytes; 2875 png_bytep dp = sp; 2876 png_uint_32 i; 2877 2878 for (i = 0; i < row_width; i++) 2879 { 2880 *(--dp) = (png_byte)(255 - *(--sp)); 2881 *(--dp) = (png_byte)(255 - *(--sp)); 2882 2883 /* This does nothing: 2884 *(--dp) = *(--sp); 2885 *(--dp) = *(--sp); 2886 *(--dp) = *(--sp); 2887 *(--dp) = *(--sp); 2888 *(--dp) = *(--sp); 2889 *(--dp) = *(--sp); 2890 We can replace it with: 2891 */ 2892 sp-=6; 2893 dp=sp; 2894 } 2895 } 2896 #endif 2897 } 2898 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) 2899 { 2900 if (row_info->bit_depth == 8) 2901 { 2902 /* This inverts the alpha channel in GA */ 2903 png_bytep sp = row + row_info->rowbytes; 2904 png_bytep dp = sp; 2905 png_uint_32 i; 2906 2907 for (i = 0; i < row_width; i++) 2908 { 2909 *(--dp) = (png_byte)(255 - *(--sp)); 2910 *(--dp) = *(--sp); 2911 } 2912 } 2913 2914 #ifdef PNG_READ_16BIT_SUPPORTED 2915 else 2916 { 2917 /* This inverts the alpha channel in GGAA */ 2918 png_bytep sp = row + row_info->rowbytes; 2919 png_bytep dp = sp; 2920 png_uint_32 i; 2921 2922 for (i = 0; i < row_width; i++) 2923 { 2924 *(--dp) = (png_byte)(255 - *(--sp)); 2925 *(--dp) = (png_byte)(255 - *(--sp)); 2926 /* 2927 *(--dp) = *(--sp); 2928 *(--dp) = *(--sp); 2929 */ 2930 sp-=2; 2931 dp=sp; 2932 } 2933 } 2934 #endif 2935 } 2936 } 2937 #endif 2938 2939 #ifdef PNG_READ_FILLER_SUPPORTED 2940 /* Add filler channel if we have RGB color */ 2941 void /* PRIVATE */ 2942 png_do_read_filler(png_row_infop row_info, png_bytep row, 2943 png_uint_32 filler, png_uint_32 flags) 2944 { 2945 png_uint_32 i; 2946 png_uint_32 row_width = row_info->width; 2947 2948 #ifdef PNG_READ_16BIT_SUPPORTED 2949 png_byte hi_filler = (png_byte)((filler>>8) & 0xff); 2950 #endif 2951 png_byte lo_filler = (png_byte)(filler & 0xff); 2952 2953 png_debug(1, "in png_do_read_filler"); 2954 2955 if ( 2956 row_info->color_type == PNG_COLOR_TYPE_GRAY) 2957 { 2958 if (row_info->bit_depth == 8) 2959 { 2960 if (flags & PNG_FLAG_FILLER_AFTER) 2961 { 2962 /* This changes the data from G to GX */ 2963 png_bytep sp = row + (png_size_t)row_width; 2964 png_bytep dp = sp + (png_size_t)row_width; 2965 for (i = 1; i < row_width; i++) 2966 { 2967 *(--dp) = lo_filler; 2968 *(--dp) = *(--sp); 2969 } 2970 *(--dp) = lo_filler; 2971 row_info->channels = 2; 2972 row_info->pixel_depth = 16; 2973 row_info->rowbytes = row_width * 2; 2974 } 2975 2976 else 2977 { 2978 /* This changes the data from G to XG */ 2979 png_bytep sp = row + (png_size_t)row_width; 2980 png_bytep dp = sp + (png_size_t)row_width; 2981 for (i = 0; i < row_width; i++) 2982 { 2983 *(--dp) = *(--sp); 2984 *(--dp) = lo_filler; 2985 } 2986 row_info->channels = 2; 2987 row_info->pixel_depth = 16; 2988 row_info->rowbytes = row_width * 2; 2989 } 2990 } 2991 2992 #ifdef PNG_READ_16BIT_SUPPORTED 2993 else if (row_info->bit_depth == 16) 2994 { 2995 if (flags & PNG_FLAG_FILLER_AFTER) 2996 { 2997 /* This changes the data from GG to GGXX */ 2998 png_bytep sp = row + (png_size_t)row_width * 2; 2999 png_bytep dp = sp + (png_size_t)row_width * 2; 3000 for (i = 1; i < row_width; i++) 3001 { 3002 *(--dp) = hi_filler; 3003 *(--dp) = lo_filler; 3004 *(--dp) = *(--sp); 3005 *(--dp) = *(--sp); 3006 } 3007 *(--dp) = hi_filler; 3008 *(--dp) = lo_filler; 3009 row_info->channels = 2; 3010 row_info->pixel_depth = 32; 3011 row_info->rowbytes = row_width * 4; 3012 } 3013 3014 else 3015 { 3016 /* This changes the data from GG to XXGG */ 3017 png_bytep sp = row + (png_size_t)row_width * 2; 3018 png_bytep dp = sp + (png_size_t)row_width * 2; 3019 for (i = 0; i < row_width; i++) 3020 { 3021 *(--dp) = *(--sp); 3022 *(--dp) = *(--sp); 3023 *(--dp) = hi_filler; 3024 *(--dp) = lo_filler; 3025 } 3026 row_info->channels = 2; 3027 row_info->pixel_depth = 32; 3028 row_info->rowbytes = row_width * 4; 3029 } 3030 } 3031 #endif 3032 } /* COLOR_TYPE == GRAY */ 3033 else if (row_info->color_type == PNG_COLOR_TYPE_RGB) 3034 { 3035 if (row_info->bit_depth == 8) 3036 { 3037 if (flags & PNG_FLAG_FILLER_AFTER) 3038 { 3039 /* This changes the data from RGB to RGBX */ 3040 png_bytep sp = row + (png_size_t)row_width * 3; 3041 png_bytep dp = sp + (png_size_t)row_width; 3042 for (i = 1; i < row_width; i++) 3043 { 3044 *(--dp) = lo_filler; 3045 *(--dp) = *(--sp); 3046 *(--dp) = *(--sp); 3047 *(--dp) = *(--sp); 3048 } 3049 *(--dp) = lo_filler; 3050 row_info->channels = 4; 3051 row_info->pixel_depth = 32; 3052 row_info->rowbytes = row_width * 4; 3053 } 3054 3055 else 3056 { 3057 /* This changes the data from RGB to XRGB */ 3058 png_bytep sp = row + (png_size_t)row_width * 3; 3059 png_bytep dp = sp + (png_size_t)row_width; 3060 for (i = 0; i < row_width; i++) 3061 { 3062 *(--dp) = *(--sp); 3063 *(--dp) = *(--sp); 3064 *(--dp) = *(--sp); 3065 *(--dp) = lo_filler; 3066 } 3067 row_info->channels = 4; 3068 row_info->pixel_depth = 32; 3069 row_info->rowbytes = row_width * 4; 3070 } 3071 } 3072 3073 #ifdef PNG_READ_16BIT_SUPPORTED 3074 else if (row_info->bit_depth == 16) 3075 { 3076 if (flags & PNG_FLAG_FILLER_AFTER) 3077 { 3078 /* This changes the data from RRGGBB to RRGGBBXX */ 3079 png_bytep sp = row + (png_size_t)row_width * 6; 3080 png_bytep dp = sp + (png_size_t)row_width * 2; 3081 for (i = 1; i < row_width; i++) 3082 { 3083 *(--dp) = hi_filler; 3084 *(--dp) = lo_filler; 3085 *(--dp) = *(--sp); 3086 *(--dp) = *(--sp); 3087 *(--dp) = *(--sp); 3088 *(--dp) = *(--sp); 3089 *(--dp) = *(--sp); 3090 *(--dp) = *(--sp); 3091 } 3092 *(--dp) = hi_filler; 3093 *(--dp) = lo_filler; 3094 row_info->channels = 4; 3095 row_info->pixel_depth = 64; 3096 row_info->rowbytes = row_width * 8; 3097 } 3098 3099 else 3100 { 3101 /* This changes the data from RRGGBB to XXRRGGBB */ 3102 png_bytep sp = row + (png_size_t)row_width * 6; 3103 png_bytep dp = sp + (png_size_t)row_width * 2; 3104 for (i = 0; i < row_width; i++) 3105 { 3106 *(--dp) = *(--sp); 3107 *(--dp) = *(--sp); 3108 *(--dp) = *(--sp); 3109 *(--dp) = *(--sp); 3110 *(--dp) = *(--sp); 3111 *(--dp) = *(--sp); 3112 *(--dp) = hi_filler; 3113 *(--dp) = lo_filler; 3114 } 3115 3116 row_info->channels = 4; 3117 row_info->pixel_depth = 64; 3118 row_info->rowbytes = row_width * 8; 3119 } 3120 } 3121 #endif 3122 } /* COLOR_TYPE == RGB */ 3123 } 3124 #endif 3125 3126 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 3127 /* Expand grayscale files to RGB, with or without alpha */ 3128 void /* PRIVATE */ 3129 png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) 3130 { 3131 png_uint_32 i; 3132 png_uint_32 row_width = row_info->width; 3133 3134 png_debug(1, "in png_do_gray_to_rgb"); 3135 3136 if (row_info->bit_depth >= 8 && 3137 !(row_info->color_type & PNG_COLOR_MASK_COLOR)) 3138 { 3139 if (row_info->color_type == PNG_COLOR_TYPE_GRAY) 3140 { 3141 if (row_info->bit_depth == 8) 3142 { 3143 /* This changes G to RGB */ 3144 png_bytep sp = row + (png_size_t)row_width - 1; 3145 png_bytep dp = sp + (png_size_t)row_width * 2; 3146 for (i = 0; i < row_width; i++) 3147 { 3148 *(dp--) = *sp; 3149 *(dp--) = *sp; 3150 *(dp--) = *(sp--); 3151 } 3152 } 3153 3154 else 3155 { 3156 /* This changes GG to RRGGBB */ 3157 png_bytep sp = row + (png_size_t)row_width * 2 - 1; 3158 png_bytep dp = sp + (png_size_t)row_width * 4; 3159 for (i = 0; i < row_width; i++) 3160 { 3161 *(dp--) = *sp; 3162 *(dp--) = *(sp - 1); 3163 *(dp--) = *sp; 3164 *(dp--) = *(sp - 1); 3165 *(dp--) = *(sp--); 3166 *(dp--) = *(sp--); 3167 } 3168 } 3169 } 3170 3171 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) 3172 { 3173 if (row_info->bit_depth == 8) 3174 { 3175 /* This changes GA to RGBA */ 3176 png_bytep sp = row + (png_size_t)row_width * 2 - 1; 3177 png_bytep dp = sp + (png_size_t)row_width * 2; 3178 for (i = 0; i < row_width; i++) 3179 { 3180 *(dp--) = *(sp--); 3181 *(dp--) = *sp; 3182 *(dp--) = *sp; 3183 *(dp--) = *(sp--); 3184 } 3185 } 3186 3187 else 3188 { 3189 /* This changes GGAA to RRGGBBAA */ 3190 png_bytep sp = row + (png_size_t)row_width * 4 - 1; 3191 png_bytep dp = sp + (png_size_t)row_width * 4; 3192 for (i = 0; i < row_width; i++) 3193 { 3194 *(dp--) = *(sp--); 3195 *(dp--) = *(sp--); 3196 *(dp--) = *sp; 3197 *(dp--) = *(sp - 1); 3198 *(dp--) = *sp; 3199 *(dp--) = *(sp - 1); 3200 *(dp--) = *(sp--); 3201 *(dp--) = *(sp--); 3202 } 3203 } 3204 } 3205 row_info->channels = (png_byte)(row_info->channels + 2); 3206 row_info->color_type |= PNG_COLOR_MASK_COLOR; 3207 row_info->pixel_depth = (png_byte)(row_info->channels * 3208 row_info->bit_depth); 3209 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); 3210 } 3211 } 3212 #endif 3213 3214 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 3215 /* Reduce RGB files to grayscale, with or without alpha 3216 * using the equation given in Poynton's ColorFAQ of 1998-01-04 at 3217 * <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008 but 3218 * versions dated 1998 through November 2002 have been archived at 3219 * http://web.archive.org/web/20000816232553/http://www.inforamp.net/ 3220 * ~poynton/notes/colour_and_gamma/ColorFAQ.txt ) 3221 * Charles Poynton poynton at poynton.com 3222 * 3223 * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B 3224 * 3225 * which can be expressed with integers as 3226 * 3227 * Y = (6969 * R + 23434 * G + 2365 * B)/32768 3228 * 3229 * Poynton's current link (as of January 2003 through July 2011): 3230 * <http://www.poynton.com/notes/colour_and_gamma/> 3231 * has changed the numbers slightly: 3232 * 3233 * Y = 0.2126*R + 0.7152*G + 0.0722*B 3234 * 3235 * which can be expressed with integers as 3236 * 3237 * Y = (6966 * R + 23436 * G + 2366 * B)/32768 3238 * 3239 * Historically, however, libpng uses numbers derived from the ITU-R Rec 709 3240 * end point chromaticities and the D65 white point. Depending on the 3241 * precision used for the D65 white point this produces a variety of different 3242 * numbers, however if the four decimal place value used in ITU-R Rec 709 is 3243 * used (0.3127,0.3290) the Y calculation would be: 3244 * 3245 * Y = (6968 * R + 23435 * G + 2366 * B)/32768 3246 * 3247 * While this is correct the rounding results in an overflow for white, because 3248 * the sum of the rounded coefficients is 32769, not 32768. Consequently 3249 * libpng uses, instead, the closest non-overflowing approximation: 3250 * 3251 * Y = (6968 * R + 23434 * G + 2366 * B)/32768 3252 * 3253 * Starting with libpng-1.5.5, if the image being converted has a cHRM chunk 3254 * (including an sRGB chunk) then the chromaticities are used to calculate the 3255 * coefficients. See the chunk handling in pngrutil.c for more information. 3256 * 3257 * In all cases the calculation is to be done in a linear colorspace. If no 3258 * gamma information is available to correct the encoding of the original RGB 3259 * values this results in an implicit assumption that the original PNG RGB 3260 * values were linear. 3261 * 3262 * Other integer coefficents can be used via png_set_rgb_to_gray(). Because 3263 * the API takes just red and green coefficients the blue coefficient is 3264 * calculated to make the sum 32768. This will result in different rounding 3265 * to that used above. 3266 */ 3267 int /* PRIVATE */ 3268 png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row) 3269 3270 { 3271 int rgb_error = 0; 3272 3273 png_debug(1, "in png_do_rgb_to_gray"); 3274 3275 if (!(row_info->color_type & PNG_COLOR_MASK_PALETTE) && 3276 (row_info->color_type & PNG_COLOR_MASK_COLOR)) 3277 { 3278 PNG_CONST png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; 3279 PNG_CONST png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; 3280 PNG_CONST png_uint_32 bc = 32768 - rc - gc; 3281 PNG_CONST png_uint_32 row_width = row_info->width; 3282 PNG_CONST int have_alpha = 3283 (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0; 3284 3285 if (row_info->bit_depth == 8) 3286 { 3287 #ifdef PNG_READ_GAMMA_SUPPORTED 3288 /* Notice that gamma to/from 1 are not necessarily inverses (if 3289 * there is an overall gamma correction). Prior to 1.5.5 this code 3290 * checked the linearized values for equality; this doesn't match 3291 * the documentation, the original values must be checked. 3292 */ 3293 if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) 3294 { 3295 png_bytep sp = row; 3296 png_bytep dp = row; 3297 png_uint_32 i; 3298 3299 for (i = 0; i < row_width; i++) 3300 { 3301 png_byte red = *(sp++); 3302 png_byte green = *(sp++); 3303 png_byte blue = *(sp++); 3304 3305 if (red != green || red != blue) 3306 { 3307 red = png_ptr->gamma_to_1[red]; 3308 green = png_ptr->gamma_to_1[green]; 3309 blue = png_ptr->gamma_to_1[blue]; 3310 3311 rgb_error |= 1; 3312 *(dp++) = png_ptr->gamma_from_1[ 3313 (rc*red + gc*green + bc*blue + 16384)>>15]; 3314 } 3315 3316 else 3317 { 3318 /* If there is no overall correction the table will not be 3319 * set. 3320 */ 3321 if (png_ptr->gamma_table != NULL) 3322 red = png_ptr->gamma_table[red]; 3323 3324 *(dp++) = red; 3325 } 3326 3327 if (have_alpha) 3328 *(dp++) = *(sp++); 3329 } 3330 } 3331 else 3332 #endif 3333 { 3334 png_bytep sp = row; 3335 png_bytep dp = row; 3336 png_uint_32 i; 3337 3338 for (i = 0; i < row_width; i++) 3339 { 3340 png_byte red = *(sp++); 3341 png_byte green = *(sp++); 3342 png_byte blue = *(sp++); 3343 3344 if (red != green || red != blue) 3345 { 3346 rgb_error |= 1; 3347 /* NOTE: this is the historical approach which simply 3348 * truncates the results. 3349 */ 3350 *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); 3351 } 3352 3353 else 3354 *(dp++) = red; 3355 3356 if (have_alpha) 3357 *(dp++) = *(sp++); 3358 } 3359 } 3360 } 3361 3362 else /* RGB bit_depth == 16 */ 3363 { 3364 #ifdef PNG_READ_GAMMA_SUPPORTED 3365 if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_1 != NULL) 3366 { 3367 png_bytep sp = row; 3368 png_bytep dp = row; 3369 png_uint_32 i; 3370 3371 for (i = 0; i < row_width; i++) 3372 { 3373 png_uint_16 red, green, blue, w; 3374 3375 red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; 3376 green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; 3377 blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; 3378 3379 if (red == green && red == blue) 3380 { 3381 if (png_ptr->gamma_16_table != NULL) 3382 w = png_ptr->gamma_16_table[(red&0xff) 3383 >> png_ptr->gamma_shift][red>>8]; 3384 3385 else 3386 w = red; 3387 } 3388 3389 else 3390 { 3391 png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) 3392 >> png_ptr->gamma_shift][red>>8]; 3393 png_uint_16 green_1 = 3394 png_ptr->gamma_16_to_1[(green&0xff) >> 3395 png_ptr->gamma_shift][green>>8]; 3396 png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) 3397 >> png_ptr->gamma_shift][blue>>8]; 3398 png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1 3399 + bc*blue_1 + 16384)>>15); 3400 w = png_ptr->gamma_16_from_1[(gray16&0xff) >> 3401 png_ptr->gamma_shift][gray16 >> 8]; 3402 rgb_error |= 1; 3403 } 3404 3405 *(dp++) = (png_byte)((w>>8) & 0xff); 3406 *(dp++) = (png_byte)(w & 0xff); 3407 3408 if (have_alpha) 3409 { 3410 *(dp++) = *(sp++); 3411 *(dp++) = *(sp++); 3412 } 3413 } 3414 } 3415 else 3416 #endif 3417 { 3418 png_bytep sp = row; 3419 png_bytep dp = row; 3420 png_uint_32 i; 3421 3422 for (i = 0; i < row_width; i++) 3423 { 3424 png_uint_16 red, green, blue, gray16; 3425 3426 red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; 3427 green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; 3428 blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; 3429 3430 if (red != green || red != blue) 3431 rgb_error |= 1; 3432 3433 /* From 1.5.5 in the 16 bit case do the accurate conversion even 3434 * in the 'fast' case - this is because this is where the code 3435 * ends up when handling linear 16 bit data. 3436 */ 3437 gray16 = (png_uint_16)((rc*red + gc*green + bc*blue + 16384) >> 3438 15); 3439 *(dp++) = (png_byte)((gray16>>8) & 0xff); 3440 *(dp++) = (png_byte)(gray16 & 0xff); 3441 3442 if (have_alpha) 3443 { 3444 *(dp++) = *(sp++); 3445 *(dp++) = *(sp++); 3446 } 3447 } 3448 } 3449 } 3450 3451 row_info->channels = (png_byte)(row_info->channels - 2); 3452 row_info->color_type = (png_byte)(row_info->color_type & 3453 ~PNG_COLOR_MASK_COLOR); 3454 row_info->pixel_depth = (png_byte)(row_info->channels * 3455 row_info->bit_depth); 3456 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); 3457 } 3458 return rgb_error; 3459 } 3460 #endif 3461 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */ 3462 3463 #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED 3464 /* Build a grayscale palette. Palette is assumed to be 1 << bit_depth 3465 * large of png_color. This lets grayscale images be treated as 3466 * paletted. Most useful for gamma correction and simplification 3467 * of code. This API is not used internally. 3468 */ 3469 void PNGAPI 3470 png_build_grayscale_palette(int bit_depth, png_colorp palette) 3471 { 3472 int num_palette; 3473 int color_inc; 3474 int i; 3475 int v; 3476 3477 png_debug(1, "in png_do_build_grayscale_palette"); 3478 3479 if (palette == NULL) 3480 return; 3481 3482 switch (bit_depth) 3483 { 3484 case 1: 3485 num_palette = 2; 3486 color_inc = 0xff; 3487 break; 3488 3489 case 2: 3490 num_palette = 4; 3491 color_inc = 0x55; 3492 break; 3493 3494 case 4: 3495 num_palette = 16; 3496 color_inc = 0x11; 3497 break; 3498 3499 case 8: 3500 num_palette = 256; 3501 color_inc = 1; 3502 break; 3503 3504 default: 3505 num_palette = 0; 3506 color_inc = 0; 3507 break; 3508 } 3509 3510 for (i = 0, v = 0; i < num_palette; i++, v += color_inc) 3511 { 3512 palette[i].red = (png_byte)v; 3513 palette[i].green = (png_byte)v; 3514 palette[i].blue = (png_byte)v; 3515 } 3516 } 3517 #endif 3518 3519 3520 #ifdef PNG_READ_TRANSFORMS_SUPPORTED 3521 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ 3522 defined(PNG_READ_ALPHA_MODE_SUPPORTED) 3523 /* Replace any alpha or transparency with the supplied background color. 3524 * "background" is already in the screen gamma, while "background_1" is 3525 * at a gamma of 1.0. Paletted files have already been taken care of. 3526 */ 3527 void /* PRIVATE */ 3528 png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr) 3529 { 3530 #ifdef PNG_READ_GAMMA_SUPPORTED 3531 png_const_bytep gamma_table = png_ptr->gamma_table; 3532 png_const_bytep gamma_from_1 = png_ptr->gamma_from_1; 3533 png_const_bytep gamma_to_1 = png_ptr->gamma_to_1; 3534 png_const_uint_16pp gamma_16 = png_ptr->gamma_16_table; 3535 png_const_uint_16pp gamma_16_from_1 = png_ptr->gamma_16_from_1; 3536 png_const_uint_16pp gamma_16_to_1 = png_ptr->gamma_16_to_1; 3537 int gamma_shift = png_ptr->gamma_shift; 3538 int optimize = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0; 3539 #endif 3540 3541 png_bytep sp; 3542 png_uint_32 i; 3543 png_uint_32 row_width = row_info->width; 3544 int shift; 3545 3546 png_debug(1, "in png_do_compose"); 3547 3548 { 3549 switch (row_info->color_type) 3550 { 3551 case PNG_COLOR_TYPE_GRAY: 3552 { 3553 switch (row_info->bit_depth) 3554 { 3555 case 1: 3556 { 3557 sp = row; 3558 shift = 7; 3559 for (i = 0; i < row_width; i++) 3560 { 3561 if ((png_uint_16)((*sp >> shift) & 0x01) 3562 == png_ptr->trans_color.gray) 3563 { 3564 unsigned int tmp = *sp & (0x7f7f >> (7 - shift)); 3565 tmp |= png_ptr->background.gray << shift; 3566 *sp = (png_byte)(tmp & 0xff); 3567 } 3568 3569 if (!shift) 3570 { 3571 shift = 7; 3572 sp++; 3573 } 3574 3575 else 3576 shift--; 3577 } 3578 break; 3579 } 3580 3581 case 2: 3582 { 3583 #ifdef PNG_READ_GAMMA_SUPPORTED 3584 if (gamma_table != NULL) 3585 { 3586 sp = row; 3587 shift = 6; 3588 for (i = 0; i < row_width; i++) 3589 { 3590 if ((png_uint_16)((*sp >> shift) & 0x03) 3591 == png_ptr->trans_color.gray) 3592 { 3593 unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); 3594 tmp |= png_ptr->background.gray << shift; 3595 *sp = (png_byte)(tmp & 0xff); 3596 } 3597 3598 else 3599 { 3600 unsigned int p = (*sp >> shift) & 0x03; 3601 unsigned int g = (gamma_table [p | (p << 2) | 3602 (p << 4) | (p << 6)] >> 6) & 0x03; 3603 unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); 3604 tmp |= g << shift; 3605 *sp = (png_byte)(tmp & 0xff); 3606 } 3607 3608 if (!shift) 3609 { 3610 shift = 6; 3611 sp++; 3612 } 3613 3614 else 3615 shift -= 2; 3616 } 3617 } 3618 3619 else 3620 #endif 3621 { 3622 sp = row; 3623 shift = 6; 3624 for (i = 0; i < row_width; i++) 3625 { 3626 if ((png_uint_16)((*sp >> shift) & 0x03) 3627 == png_ptr->trans_color.gray) 3628 { 3629 unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); 3630 tmp |= png_ptr->background.gray << shift; 3631 *sp = (png_byte)(tmp & 0xff); 3632 } 3633 3634 if (!shift) 3635 { 3636 shift = 6; 3637 sp++; 3638 } 3639 3640 else 3641 shift -= 2; 3642 } 3643 } 3644 break; 3645 } 3646 3647 case 4: 3648 { 3649 #ifdef PNG_READ_GAMMA_SUPPORTED 3650 if (gamma_table != NULL) 3651 { 3652 sp = row; 3653 shift = 4; 3654 for (i = 0; i < row_width; i++) 3655 { 3656 if ((png_uint_16)((*sp >> shift) & 0x0f) 3657 == png_ptr->trans_color.gray) 3658 { 3659 unsigned int tmp = *sp & (0xf0f >> (4 - shift)); 3660 tmp |= png_ptr->background.gray << shift; 3661 *sp = (png_byte)(tmp & 0xff); 3662 } 3663 3664 else 3665 { 3666 unsigned int p = (*sp >> shift) & 0x0f; 3667 unsigned int g = (gamma_table[p | (p << 4)] >> 4) & 3668 0x0f; 3669 unsigned int tmp = *sp & (0xf0f >> (4 - shift)); 3670 tmp |= g << shift; 3671 *sp = (png_byte)(tmp & 0xff); 3672 } 3673 3674 if (!shift) 3675 { 3676 shift = 4; 3677 sp++; 3678 } 3679 3680 else 3681 shift -= 4; 3682 } 3683 } 3684 3685 else 3686 #endif 3687 { 3688 sp = row; 3689 shift = 4; 3690 for (i = 0; i < row_width; i++) 3691 { 3692 if ((png_uint_16)((*sp >> shift) & 0x0f) 3693 == png_ptr->trans_color.gray) 3694 { 3695 unsigned int tmp = *sp & (0xf0f >> (4 - shift)); 3696 tmp |= png_ptr->background.gray << shift; 3697 *sp = (png_byte)(tmp & 0xff); 3698 } 3699 3700 if (!shift) 3701 { 3702 shift = 4; 3703 sp++; 3704 } 3705 3706 else 3707 shift -= 4; 3708 } 3709 } 3710 break; 3711 } 3712 3713 case 8: 3714 { 3715 #ifdef PNG_READ_GAMMA_SUPPORTED 3716 if (gamma_table != NULL) 3717 { 3718 sp = row; 3719 for (i = 0; i < row_width; i++, sp++) 3720 { 3721 if (*sp == png_ptr->trans_color.gray) 3722 *sp = (png_byte)png_ptr->background.gray; 3723 3724 else 3725 *sp = gamma_table[*sp]; 3726 } 3727 } 3728 else 3729 #endif 3730 { 3731 sp = row; 3732 for (i = 0; i < row_width; i++, sp++) 3733 { 3734 if (*sp == png_ptr->trans_color.gray) 3735 *sp = (png_byte)png_ptr->background.gray; 3736 } 3737 } 3738 break; 3739 } 3740 3741 case 16: 3742 { 3743 #ifdef PNG_READ_GAMMA_SUPPORTED 3744 if (gamma_16 != NULL) 3745 { 3746 sp = row; 3747 for (i = 0; i < row_width; i++, sp += 2) 3748 { 3749 png_uint_16 v; 3750 3751 v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); 3752 3753 if (v == png_ptr->trans_color.gray) 3754 { 3755 /* Background is already in screen gamma */ 3756 *sp = (png_byte)((png_ptr->background.gray >> 8) 3757 & 0xff); 3758 *(sp + 1) = (png_byte)(png_ptr->background.gray 3759 & 0xff); 3760 } 3761 3762 else 3763 { 3764 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; 3765 *sp = (png_byte)((v >> 8) & 0xff); 3766 *(sp + 1) = (png_byte)(v & 0xff); 3767 } 3768 } 3769 } 3770 else 3771 #endif 3772 { 3773 sp = row; 3774 for (i = 0; i < row_width; i++, sp += 2) 3775 { 3776 png_uint_16 v; 3777 3778 v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); 3779 3780 if (v == png_ptr->trans_color.gray) 3781 { 3782 *sp = (png_byte)((png_ptr->background.gray >> 8) 3783 & 0xff); 3784 *(sp + 1) = (png_byte)(png_ptr->background.gray 3785 & 0xff); 3786 } 3787 } 3788 } 3789 break; 3790 } 3791 3792 default: 3793 break; 3794 } 3795 break; 3796 } 3797 3798 case PNG_COLOR_TYPE_RGB: 3799 { 3800 if (row_info->bit_depth == 8) 3801 { 3802 #ifdef PNG_READ_GAMMA_SUPPORTED 3803 if (gamma_table != NULL) 3804 { 3805 sp = row; 3806 for (i = 0; i < row_width; i++, sp += 3) 3807 { 3808 if (*sp == png_ptr->trans_color.red && 3809 *(sp + 1) == png_ptr->trans_color.green && 3810 *(sp + 2) == png_ptr->trans_color.blue) 3811 { 3812 *sp = (png_byte)png_ptr->background.red; 3813 *(sp + 1) = (png_byte)png_ptr->background.green; 3814 *(sp + 2) = (png_byte)png_ptr->background.blue; 3815 } 3816 3817 else 3818 { 3819 *sp = gamma_table[*sp]; 3820 *(sp + 1) = gamma_table[*(sp + 1)]; 3821 *(sp + 2) = gamma_table[*(sp + 2)]; 3822 } 3823 } 3824 } 3825 else 3826 #endif 3827 { 3828 sp = row; 3829 for (i = 0; i < row_width; i++, sp += 3) 3830 { 3831 if (*sp == png_ptr->trans_color.red && 3832 *(sp + 1) == png_ptr->trans_color.green && 3833 *(sp + 2) == png_ptr->trans_color.blue) 3834 { 3835 *sp = (png_byte)png_ptr->background.red; 3836 *(sp + 1) = (png_byte)png_ptr->background.green; 3837 *(sp + 2) = (png_byte)png_ptr->background.blue; 3838 } 3839 } 3840 } 3841 } 3842 else /* if (row_info->bit_depth == 16) */ 3843 { 3844 #ifdef PNG_READ_GAMMA_SUPPORTED 3845 if (gamma_16 != NULL) 3846 { 3847 sp = row; 3848 for (i = 0; i < row_width; i++, sp += 6) 3849 { 3850 png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); 3851 3852 png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) 3853 + *(sp + 3)); 3854 3855 png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) 3856 + *(sp + 5)); 3857 3858 if (r == png_ptr->trans_color.red && 3859 g == png_ptr->trans_color.green && 3860 b == png_ptr->trans_color.blue) 3861 { 3862 /* Background is already in screen gamma */ 3863 *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); 3864 *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); 3865 *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) 3866 & 0xff); 3867 *(sp + 3) = (png_byte)(png_ptr->background.green 3868 & 0xff); 3869 *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) 3870 & 0xff); 3871 *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); 3872 } 3873 3874 else 3875 { 3876 png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; 3877 *sp = (png_byte)((v >> 8) & 0xff); 3878 *(sp + 1) = (png_byte)(v & 0xff); 3879 3880 v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; 3881 *(sp + 2) = (png_byte)((v >> 8) & 0xff); 3882 *(sp + 3) = (png_byte)(v & 0xff); 3883 3884 v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; 3885 *(sp + 4) = (png_byte)((v >> 8) & 0xff); 3886 *(sp + 5) = (png_byte)(v & 0xff); 3887 } 3888 } 3889 } 3890 3891 else 3892 #endif 3893 { 3894 sp = row; 3895 for (i = 0; i < row_width; i++, sp += 6) 3896 { 3897 png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); 3898 3899 png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) 3900 + *(sp + 3)); 3901 3902 png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) 3903 + *(sp + 5)); 3904 3905 if (r == png_ptr->trans_color.red && 3906 g == png_ptr->trans_color.green && 3907 b == png_ptr->trans_color.blue) 3908 { 3909 *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); 3910 *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); 3911 *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) 3912 & 0xff); 3913 *(sp + 3) = (png_byte)(png_ptr->background.green 3914 & 0xff); 3915 *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) 3916 & 0xff); 3917 *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); 3918 } 3919 } 3920 } 3921 } 3922 break; 3923 } 3924 3925 case PNG_COLOR_TYPE_GRAY_ALPHA: 3926 { 3927 if (row_info->bit_depth == 8) 3928 { 3929 #ifdef PNG_READ_GAMMA_SUPPORTED 3930 if (gamma_to_1 != NULL && gamma_from_1 != NULL && 3931 gamma_table != NULL) 3932 { 3933 sp = row; 3934 for (i = 0; i < row_width; i++, sp += 2) 3935 { 3936 png_uint_16 a = *(sp + 1); 3937 3938 if (a == 0xff) 3939 *sp = gamma_table[*sp]; 3940 3941 else if (a == 0) 3942 { 3943 /* Background is already in screen gamma */ 3944 *sp = (png_byte)png_ptr->background.gray; 3945 } 3946 3947 else 3948 { 3949 png_byte v, w; 3950 3951 v = gamma_to_1[*sp]; 3952 png_composite(w, v, a, png_ptr->background_1.gray); 3953 if (!optimize) 3954 w = gamma_from_1[w]; 3955 *sp = w; 3956 } 3957 } 3958 } 3959 else 3960 #endif 3961 { 3962 sp = row; 3963 for (i = 0; i < row_width; i++, sp += 2) 3964 { 3965 png_byte a = *(sp + 1); 3966 3967 if (a == 0) 3968 *sp = (png_byte)png_ptr->background.gray; 3969 3970 else if (a < 0xff) 3971 png_composite(*sp, *sp, a, png_ptr->background.gray); 3972 } 3973 } 3974 } 3975 else /* if (png_ptr->bit_depth == 16) */ 3976 { 3977 #ifdef PNG_READ_GAMMA_SUPPORTED 3978 if (gamma_16 != NULL && gamma_16_from_1 != NULL && 3979 gamma_16_to_1 != NULL) 3980 { 3981 sp = row; 3982 for (i = 0; i < row_width; i++, sp += 4) 3983 { 3984 png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) 3985 + *(sp + 3)); 3986 3987 if (a == (png_uint_16)0xffff) 3988 { 3989 png_uint_16 v; 3990 3991 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; 3992 *sp = (png_byte)((v >> 8) & 0xff); 3993 *(sp + 1) = (png_byte)(v & 0xff); 3994 } 3995 3996 else if (a == 0) 3997 { 3998 /* Background is already in screen gamma */ 3999 *sp = (png_byte)((png_ptr->background.gray >> 8) 4000 & 0xff); 4001 *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); 4002 } 4003 4004 else 4005 { 4006 png_uint_16 g, v, w; 4007 4008 g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; 4009 png_composite_16(v, g, a, png_ptr->background_1.gray); 4010 if (optimize) 4011 w = v; 4012 else 4013 w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; 4014 *sp = (png_byte)((w >> 8) & 0xff); 4015 *(sp + 1) = (png_byte)(w & 0xff); 4016 } 4017 } 4018 } 4019 else 4020 #endif 4021 { 4022 sp = row; 4023 for (i = 0; i < row_width; i++, sp += 4) 4024 { 4025 png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) 4026 + *(sp + 3)); 4027 4028 if (a == 0) 4029 { 4030 *sp = (png_byte)((png_ptr->background.gray >> 8) 4031 & 0xff); 4032 *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); 4033 } 4034 4035 else if (a < 0xffff) 4036 { 4037 png_uint_16 g, v; 4038 4039 g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); 4040 png_composite_16(v, g, a, png_ptr->background.gray); 4041 *sp = (png_byte)((v >> 8) & 0xff); 4042 *(sp + 1) = (png_byte)(v & 0xff); 4043 } 4044 } 4045 } 4046 } 4047 break; 4048 } 4049 4050 case PNG_COLOR_TYPE_RGB_ALPHA: 4051 { 4052 if (row_info->bit_depth == 8) 4053 { 4054 #ifdef PNG_READ_GAMMA_SUPPORTED 4055 if (gamma_to_1 != NULL && gamma_from_1 != NULL && 4056 gamma_table != NULL) 4057 { 4058 sp = row; 4059 for (i = 0; i < row_width; i++, sp += 4) 4060 { 4061 png_byte a = *(sp + 3); 4062 4063 if (a == 0xff) 4064 { 4065 *sp = gamma_table[*sp]; 4066 *(sp + 1) = gamma_table[*(sp + 1)]; 4067 *(sp + 2) = gamma_table[*(sp + 2)]; 4068 } 4069 4070 else if (a == 0) 4071 { 4072 /* Background is already in screen gamma */ 4073 *sp = (png_byte)png_ptr->background.red; 4074 *(sp + 1) = (png_byte)png_ptr->background.green; 4075 *(sp + 2) = (png_byte)png_ptr->background.blue; 4076 } 4077 4078 else 4079 { 4080 png_byte v, w; 4081 4082 v = gamma_to_1[*sp]; 4083 png_composite(w, v, a, png_ptr->background_1.red); 4084 if (!optimize) w = gamma_from_1[w]; 4085 *sp = w; 4086 4087 v = gamma_to_1[*(sp + 1)]; 4088 png_composite(w, v, a, png_ptr->background_1.green); 4089 if (!optimize) w = gamma_from_1[w]; 4090 *(sp + 1) = w; 4091 4092 v = gamma_to_1[*(sp + 2)]; 4093 png_composite(w, v, a, png_ptr->background_1.blue); 4094 if (!optimize) w = gamma_from_1[w]; 4095 *(sp + 2) = w; 4096 } 4097 } 4098 } 4099 else 4100 #endif 4101 { 4102 sp = row; 4103 for (i = 0; i < row_width; i++, sp += 4) 4104 { 4105 png_byte a = *(sp + 3); 4106 4107 if (a == 0) 4108 { 4109 *sp = (png_byte)png_ptr->background.red; 4110 *(sp + 1) = (png_byte)png_ptr->background.green; 4111 *(sp + 2) = (png_byte)png_ptr->background.blue; 4112 } 4113 4114 else if (a < 0xff) 4115 { 4116 png_composite(*sp, *sp, a, png_ptr->background.red); 4117 4118 png_composite(*(sp + 1), *(sp + 1), a, 4119 png_ptr->background.green); 4120 4121 png_composite(*(sp + 2), *(sp + 2), a, 4122 png_ptr->background.blue); 4123 } 4124 } 4125 } 4126 } 4127 else /* if (row_info->bit_depth == 16) */ 4128 { 4129 #ifdef PNG_READ_GAMMA_SUPPORTED 4130 if (gamma_16 != NULL && gamma_16_from_1 != NULL && 4131 gamma_16_to_1 != NULL) 4132 { 4133 sp = row; 4134 for (i = 0; i < row_width; i++, sp += 8) 4135 { 4136 png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) 4137 << 8) + (png_uint_16)(*(sp + 7))); 4138 4139 if (a == (png_uint_16)0xffff) 4140 { 4141 png_uint_16 v; 4142 4143 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; 4144 *sp = (png_byte)((v >> 8) & 0xff); 4145 *(sp + 1) = (png_byte)(v & 0xff); 4146 4147 v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; 4148 *(sp + 2) = (png_byte)((v >> 8) & 0xff); 4149 *(sp + 3) = (png_byte)(v & 0xff); 4150 4151 v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; 4152 *(sp + 4) = (png_byte)((v >> 8) & 0xff); 4153 *(sp + 5) = (png_byte)(v & 0xff); 4154 } 4155 4156 else if (a == 0) 4157 { 4158 /* Background is already in screen gamma */ 4159 *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); 4160 *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); 4161 *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) 4162 & 0xff); 4163 *(sp + 3) = (png_byte)(png_ptr->background.green 4164 & 0xff); 4165 *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) 4166 & 0xff); 4167 *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); 4168 } 4169 4170 else 4171 { 4172 png_uint_16 v, w; 4173 4174 v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; 4175 png_composite_16(w, v, a, png_ptr->background_1.red); 4176 if (!optimize) 4177 w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 4178 8]; 4179 *sp = (png_byte)((w >> 8) & 0xff); 4180 *(sp + 1) = (png_byte)(w & 0xff); 4181 4182 v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; 4183 png_composite_16(w, v, a, png_ptr->background_1.green); 4184 if (!optimize) 4185 w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 4186 8]; 4187 4188 *(sp + 2) = (png_byte)((w >> 8) & 0xff); 4189 *(sp + 3) = (png_byte)(w & 0xff); 4190 4191 v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; 4192 png_composite_16(w, v, a, png_ptr->background_1.blue); 4193 if (!optimize) 4194 w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 4195 8]; 4196 4197 *(sp + 4) = (png_byte)((w >> 8) & 0xff); 4198 *(sp + 5) = (png_byte)(w & 0xff); 4199 } 4200 } 4201 } 4202 4203 else 4204 #endif 4205 { 4206 sp = row; 4207 for (i = 0; i < row_width; i++, sp += 8) 4208 { 4209 png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) 4210 << 8) + (png_uint_16)(*(sp + 7))); 4211 4212 if (a == 0) 4213 { 4214 *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); 4215 *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); 4216 *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) 4217 & 0xff); 4218 *(sp + 3) = (png_byte)(png_ptr->background.green 4219 & 0xff); 4220 *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) 4221 & 0xff); 4222 *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); 4223 } 4224 4225 else if (a < 0xffff) 4226 { 4227 png_uint_16 v; 4228 4229 png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); 4230 png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) 4231 + *(sp + 3)); 4232 png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) 4233 + *(sp + 5)); 4234 4235 png_composite_16(v, r, a, png_ptr->background.red); 4236 *sp = (png_byte)((v >> 8) & 0xff); 4237 *(sp + 1) = (png_byte)(v & 0xff); 4238 4239 png_composite_16(v, g, a, png_ptr->background.green); 4240 *(sp + 2) = (png_byte)((v >> 8) & 0xff); 4241 *(sp + 3) = (png_byte)(v & 0xff); 4242 4243 png_composite_16(v, b, a, png_ptr->background.blue); 4244 *(sp + 4) = (png_byte)((v >> 8) & 0xff); 4245 *(sp + 5) = (png_byte)(v & 0xff); 4246 } 4247 } 4248 } 4249 } 4250 break; 4251 } 4252 4253 default: 4254 break; 4255 } 4256 } 4257 } 4258 #endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_READ_ALPHA_MODE_SUPPORTED */ 4259 4260 #ifdef PNG_READ_GAMMA_SUPPORTED 4261 /* Gamma correct the image, avoiding the alpha channel. Make sure 4262 * you do this after you deal with the transparency issue on grayscale 4263 * or RGB images. If your bit depth is 8, use gamma_table, if it 4264 * is 16, use gamma_16_table and gamma_shift. Build these with 4265 * build_gamma_table(). 4266 */ 4267 void /* PRIVATE */ 4268 png_do_gamma(png_row_infop row_info, png_bytep row, png_structrp png_ptr) 4269 { 4270 png_const_bytep gamma_table = png_ptr->gamma_table; 4271 png_const_uint_16pp gamma_16_table = png_ptr->gamma_16_table; 4272 int gamma_shift = png_ptr->gamma_shift; 4273 4274 png_bytep sp; 4275 png_uint_32 i; 4276 png_uint_32 row_width=row_info->width; 4277 4278 png_debug(1, "in png_do_gamma"); 4279 4280 if (((row_info->bit_depth <= 8 && gamma_table != NULL) || 4281 (row_info->bit_depth == 16 && gamma_16_table != NULL))) 4282 { 4283 switch (row_info->color_type) 4284 { 4285 case PNG_COLOR_TYPE_RGB: 4286 { 4287 if (row_info->bit_depth == 8) 4288 { 4289 sp = row; 4290 for (i = 0; i < row_width; i++) 4291 { 4292 *sp = gamma_table[*sp]; 4293 sp++; 4294 *sp = gamma_table[*sp]; 4295 sp++; 4296 *sp = gamma_table[*sp]; 4297 sp++; 4298 } 4299 } 4300 4301 else /* if (row_info->bit_depth == 16) */ 4302 { 4303 sp = row; 4304 for (i = 0; i < row_width; i++) 4305 { 4306 png_uint_16 v; 4307 4308 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4309 *sp = (png_byte)((v >> 8) & 0xff); 4310 *(sp + 1) = (png_byte)(v & 0xff); 4311 sp += 2; 4312 4313 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4314 *sp = (png_byte)((v >> 8) & 0xff); 4315 *(sp + 1) = (png_byte)(v & 0xff); 4316 sp += 2; 4317 4318 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4319 *sp = (png_byte)((v >> 8) & 0xff); 4320 *(sp + 1) = (png_byte)(v & 0xff); 4321 sp += 2; 4322 } 4323 } 4324 break; 4325 } 4326 4327 case PNG_COLOR_TYPE_RGB_ALPHA: 4328 { 4329 if (row_info->bit_depth == 8) 4330 { 4331 sp = row; 4332 for (i = 0; i < row_width; i++) 4333 { 4334 *sp = gamma_table[*sp]; 4335 sp++; 4336 4337 *sp = gamma_table[*sp]; 4338 sp++; 4339 4340 *sp = gamma_table[*sp]; 4341 sp++; 4342 4343 sp++; 4344 } 4345 } 4346 4347 else /* if (row_info->bit_depth == 16) */ 4348 { 4349 sp = row; 4350 for (i = 0; i < row_width; i++) 4351 { 4352 png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4353 *sp = (png_byte)((v >> 8) & 0xff); 4354 *(sp + 1) = (png_byte)(v & 0xff); 4355 sp += 2; 4356 4357 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4358 *sp = (png_byte)((v >> 8) & 0xff); 4359 *(sp + 1) = (png_byte)(v & 0xff); 4360 sp += 2; 4361 4362 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4363 *sp = (png_byte)((v >> 8) & 0xff); 4364 *(sp + 1) = (png_byte)(v & 0xff); 4365 sp += 4; 4366 } 4367 } 4368 break; 4369 } 4370 4371 case PNG_COLOR_TYPE_GRAY_ALPHA: 4372 { 4373 if (row_info->bit_depth == 8) 4374 { 4375 sp = row; 4376 for (i = 0; i < row_width; i++) 4377 { 4378 *sp = gamma_table[*sp]; 4379 sp += 2; 4380 } 4381 } 4382 4383 else /* if (row_info->bit_depth == 16) */ 4384 { 4385 sp = row; 4386 for (i = 0; i < row_width; i++) 4387 { 4388 png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4389 *sp = (png_byte)((v >> 8) & 0xff); 4390 *(sp + 1) = (png_byte)(v & 0xff); 4391 sp += 4; 4392 } 4393 } 4394 break; 4395 } 4396 4397 case PNG_COLOR_TYPE_GRAY: 4398 { 4399 if (row_info->bit_depth == 2) 4400 { 4401 sp = row; 4402 for (i = 0; i < row_width; i += 4) 4403 { 4404 int a = *sp & 0xc0; 4405 int b = *sp & 0x30; 4406 int c = *sp & 0x0c; 4407 int d = *sp & 0x03; 4408 4409 *sp = (png_byte)( 4410 ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)| 4411 ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)| 4412 ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)| 4413 ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) )); 4414 sp++; 4415 } 4416 } 4417 4418 if (row_info->bit_depth == 4) 4419 { 4420 sp = row; 4421 for (i = 0; i < row_width; i += 2) 4422 { 4423 int msb = *sp & 0xf0; 4424 int lsb = *sp & 0x0f; 4425 4426 *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0) 4427 | (((int)gamma_table[(lsb << 4) | lsb]) >> 4)); 4428 sp++; 4429 } 4430 } 4431 4432 else if (row_info->bit_depth == 8) 4433 { 4434 sp = row; 4435 for (i = 0; i < row_width; i++) 4436 { 4437 *sp = gamma_table[*sp]; 4438 sp++; 4439 } 4440 } 4441 4442 else if (row_info->bit_depth == 16) 4443 { 4444 sp = row; 4445 for (i = 0; i < row_width; i++) 4446 { 4447 png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; 4448 *sp = (png_byte)((v >> 8) & 0xff); 4449 *(sp + 1) = (png_byte)(v & 0xff); 4450 sp += 2; 4451 } 4452 } 4453 break; 4454 } 4455 4456 default: 4457 break; 4458 } 4459 } 4460 } 4461 #endif 4462 4463 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED 4464 /* Encode the alpha channel to the output gamma (the input channel is always 4465 * linear.) Called only with color types that have an alpha channel. Needs the 4466 * from_1 tables. 4467 */ 4468 void /* PRIVATE */ 4469 png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr) 4470 { 4471 png_uint_32 row_width = row_info->width; 4472 4473 png_debug(1, "in png_do_encode_alpha"); 4474 4475 if (row_info->color_type & PNG_COLOR_MASK_ALPHA) 4476 { 4477 if (row_info->bit_depth == 8) 4478 { 4479 PNG_CONST png_bytep table = png_ptr->gamma_from_1; 4480 4481 if (table != NULL) 4482 { 4483 PNG_CONST int step = 4484 (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2; 4485 4486 /* The alpha channel is the last component: */ 4487 row += step - 1; 4488 4489 for (; row_width > 0; --row_width, row += step) 4490 *row = table[*row]; 4491 4492 return; 4493 } 4494 } 4495 4496 else if (row_info->bit_depth == 16) 4497 { 4498 PNG_CONST png_uint_16pp table = png_ptr->gamma_16_from_1; 4499 PNG_CONST int gamma_shift = png_ptr->gamma_shift; 4500 4501 if (table != NULL) 4502 { 4503 PNG_CONST int step = 4504 (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4; 4505 4506 /* The alpha channel is the last component: */ 4507 row += step - 2; 4508 4509 for (; row_width > 0; --row_width, row += step) 4510 { 4511 png_uint_16 v; 4512 4513 v = table[*(row + 1) >> gamma_shift][*row]; 4514 *row = (png_byte)((v >> 8) & 0xff); 4515 *(row + 1) = (png_byte)(v & 0xff); 4516 } 4517 4518 return; 4519 } 4520 } 4521 } 4522 4523 /* Only get to here if called with a weird row_info; no harm has been done, 4524 * so just issue a warning. 4525 */ 4526 png_warning(png_ptr, "png_do_encode_alpha: unexpected call"); 4527 } 4528 #endif 4529 4530 #ifdef PNG_READ_EXPAND_SUPPORTED 4531 /* Expands a palette row to an RGB or RGBA row depending 4532 * upon whether you supply trans and num_trans. 4533 */ 4534 void /* PRIVATE */ 4535 png_do_expand_palette(png_row_infop row_info, png_bytep row, 4536 png_const_colorp palette, png_const_bytep trans_alpha, int num_trans) 4537 { 4538 int shift, value; 4539 png_bytep sp, dp; 4540 png_uint_32 i; 4541 png_uint_32 row_width=row_info->width; 4542 4543 png_debug(1, "in png_do_expand_palette"); 4544 4545 if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) 4546 { 4547 if (row_info->bit_depth < 8) 4548 { 4549 switch (row_info->bit_depth) 4550 { 4551 case 1: 4552 { 4553 sp = row + (png_size_t)((row_width - 1) >> 3); 4554 dp = row + (png_size_t)row_width - 1; 4555 shift = 7 - (int)((row_width + 7) & 0x07); 4556 for (i = 0; i < row_width; i++) 4557 { 4558 if ((*sp >> shift) & 0x01) 4559 *dp = 1; 4560 4561 else 4562 *dp = 0; 4563 4564 if (shift == 7) 4565 { 4566 shift = 0; 4567 sp--; 4568 } 4569 4570 else 4571 shift++; 4572 4573 dp--; 4574 } 4575 break; 4576 } 4577 4578 case 2: 4579 { 4580 sp = row + (png_size_t)((row_width - 1) >> 2); 4581 dp = row + (png_size_t)row_width - 1; 4582 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); 4583 for (i = 0; i < row_width; i++) 4584 { 4585 value = (*sp >> shift) & 0x03; 4586 *dp = (png_byte)value; 4587 if (shift == 6) 4588 { 4589 shift = 0; 4590 sp--; 4591 } 4592 4593 else 4594 shift += 2; 4595 4596 dp--; 4597 } 4598 break; 4599 } 4600 4601 case 4: 4602 { 4603 sp = row + (png_size_t)((row_width - 1) >> 1); 4604 dp = row + (png_size_t)row_width - 1; 4605 shift = (int)((row_width & 0x01) << 2); 4606 for (i = 0; i < row_width; i++) 4607 { 4608 value = (*sp >> shift) & 0x0f; 4609 *dp = (png_byte)value; 4610 if (shift == 4) 4611 { 4612 shift = 0; 4613 sp--; 4614 } 4615 4616 else 4617 shift += 4; 4618 4619 dp--; 4620 } 4621 break; 4622 } 4623 4624 default: 4625 break; 4626 } 4627 row_info->bit_depth = 8; 4628 row_info->pixel_depth = 8; 4629 row_info->rowbytes = row_width; 4630 } 4631 4632 if (row_info->bit_depth == 8) 4633 { 4634 { 4635 if (num_trans > 0) 4636 { 4637 sp = row + (png_size_t)row_width - 1; 4638 dp = row + (png_size_t)(row_width << 2) - 1; 4639 4640 for (i = 0; i < row_width; i++) 4641 { 4642 if ((int)(*sp) >= num_trans) 4643 *dp-- = 0xff; 4644 4645 else 4646 *dp-- = trans_alpha[*sp]; 4647 4648 *dp-- = palette[*sp].blue; 4649 *dp-- = palette[*sp].green; 4650 *dp-- = palette[*sp].red; 4651 sp--; 4652 } 4653 row_info->bit_depth = 8; 4654 row_info->pixel_depth = 32; 4655 row_info->rowbytes = row_width * 4; 4656 row_info->color_type = 6; 4657 row_info->channels = 4; 4658 } 4659 4660 else 4661 { 4662 sp = row + (png_size_t)row_width - 1; 4663 dp = row + (png_size_t)(row_width * 3) - 1; 4664 4665 for (i = 0; i < row_width; i++) 4666 { 4667 *dp-- = palette[*sp].blue; 4668 *dp-- = palette[*sp].green; 4669 *dp-- = palette[*sp].red; 4670 sp--; 4671 } 4672 4673 row_info->bit_depth = 8; 4674 row_info->pixel_depth = 24; 4675 row_info->rowbytes = row_width * 3; 4676 row_info->color_type = 2; 4677 row_info->channels = 3; 4678 } 4679 } 4680 } 4681 } 4682 } 4683 4684 /* If the bit depth < 8, it is expanded to 8. Also, if the already 4685 * expanded transparency value is supplied, an alpha channel is built. 4686 */ 4687 void /* PRIVATE */ 4688 png_do_expand(png_row_infop row_info, png_bytep row, 4689 png_const_color_16p trans_color) 4690 { 4691 int shift, value; 4692 png_bytep sp, dp; 4693 png_uint_32 i; 4694 png_uint_32 row_width=row_info->width; 4695 4696 png_debug(1, "in png_do_expand"); 4697 4698 { 4699 if (row_info->color_type == PNG_COLOR_TYPE_GRAY) 4700 { 4701 unsigned int gray = trans_color ? trans_color->gray : 0; 4702 4703 if (row_info->bit_depth < 8) 4704 { 4705 switch (row_info->bit_depth) 4706 { 4707 case 1: 4708 { 4709 gray = (gray & 0x01) * 0xff; 4710 sp = row + (png_size_t)((row_width - 1) >> 3); 4711 dp = row + (png_size_t)row_width - 1; 4712 shift = 7 - (int)((row_width + 7) & 0x07); 4713 for (i = 0; i < row_width; i++) 4714 { 4715 if ((*sp >> shift) & 0x01) 4716 *dp = 0xff; 4717 4718 else 4719 *dp = 0; 4720 4721 if (shift == 7) 4722 { 4723 shift = 0; 4724 sp--; 4725 } 4726 4727 else 4728 shift++; 4729 4730 dp--; 4731 } 4732 break; 4733 } 4734 4735 case 2: 4736 { 4737 gray = (gray & 0x03) * 0x55; 4738 sp = row + (png_size_t)((row_width - 1) >> 2); 4739 dp = row + (png_size_t)row_width - 1; 4740 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); 4741 for (i = 0; i < row_width; i++) 4742 { 4743 value = (*sp >> shift) & 0x03; 4744 *dp = (png_byte)(value | (value << 2) | (value << 4) | 4745 (value << 6)); 4746 if (shift == 6) 4747 { 4748 shift = 0; 4749 sp--; 4750 } 4751 4752 else 4753 shift += 2; 4754 4755 dp--; 4756 } 4757 break; 4758 } 4759 4760 case 4: 4761 { 4762 gray = (gray & 0x0f) * 0x11; 4763 sp = row + (png_size_t)((row_width - 1) >> 1); 4764 dp = row + (png_size_t)row_width - 1; 4765 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); 4766 for (i = 0; i < row_width; i++) 4767 { 4768 value = (*sp >> shift) & 0x0f; 4769 *dp = (png_byte)(value | (value << 4)); 4770 if (shift == 4) 4771 { 4772 shift = 0; 4773 sp--; 4774 } 4775 4776 else 4777 shift = 4; 4778 4779 dp--; 4780 } 4781 break; 4782 } 4783 4784 default: 4785 break; 4786 } 4787 4788 row_info->bit_depth = 8; 4789 row_info->pixel_depth = 8; 4790 row_info->rowbytes = row_width; 4791 } 4792 4793 if (trans_color != NULL) 4794 { 4795 if (row_info->bit_depth == 8) 4796 { 4797 gray = gray & 0xff; 4798 sp = row + (png_size_t)row_width - 1; 4799 dp = row + (png_size_t)(row_width << 1) - 1; 4800 4801 for (i = 0; i < row_width; i++) 4802 { 4803 if (*sp == gray) 4804 *dp-- = 0; 4805 4806 else 4807 *dp-- = 0xff; 4808 4809 *dp-- = *sp--; 4810 } 4811 } 4812 4813 else if (row_info->bit_depth == 16) 4814 { 4815 unsigned int gray_high = (gray >> 8) & 0xff; 4816 unsigned int gray_low = gray & 0xff; 4817 sp = row + row_info->rowbytes - 1; 4818 dp = row + (row_info->rowbytes << 1) - 1; 4819 for (i = 0; i < row_width; i++) 4820 { 4821 if (*(sp - 1) == gray_high && *(sp) == gray_low) 4822 { 4823 *dp-- = 0; 4824 *dp-- = 0; 4825 } 4826 4827 else 4828 { 4829 *dp-- = 0xff; 4830 *dp-- = 0xff; 4831 } 4832 4833 *dp-- = *sp--; 4834 *dp-- = *sp--; 4835 } 4836 } 4837 4838 row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; 4839 row_info->channels = 2; 4840 row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); 4841 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, 4842 row_width); 4843 } 4844 } 4845 else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_color) 4846 { 4847 if (row_info->bit_depth == 8) 4848 { 4849 png_byte red = (png_byte)(trans_color->red & 0xff); 4850 png_byte green = (png_byte)(trans_color->green & 0xff); 4851 png_byte blue = (png_byte)(trans_color->blue & 0xff); 4852 sp = row + (png_size_t)row_info->rowbytes - 1; 4853 dp = row + (png_size_t)(row_width << 2) - 1; 4854 for (i = 0; i < row_width; i++) 4855 { 4856 if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue) 4857 *dp-- = 0; 4858 4859 else 4860 *dp-- = 0xff; 4861 4862 *dp-- = *sp--; 4863 *dp-- = *sp--; 4864 *dp-- = *sp--; 4865 } 4866 } 4867 else if (row_info->bit_depth == 16) 4868 { 4869 png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff); 4870 png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff); 4871 png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff); 4872 png_byte red_low = (png_byte)(trans_color->red & 0xff); 4873 png_byte green_low = (png_byte)(trans_color->green & 0xff); 4874 png_byte blue_low = (png_byte)(trans_color->blue & 0xff); 4875 sp = row + row_info->rowbytes - 1; 4876 dp = row + (png_size_t)(row_width << 3) - 1; 4877 for (i = 0; i < row_width; i++) 4878 { 4879 if (*(sp - 5) == red_high && 4880 *(sp - 4) == red_low && 4881 *(sp - 3) == green_high && 4882 *(sp - 2) == green_low && 4883 *(sp - 1) == blue_high && 4884 *(sp ) == blue_low) 4885 { 4886 *dp-- = 0; 4887 *dp-- = 0; 4888 } 4889 4890 else 4891 { 4892 *dp-- = 0xff; 4893 *dp-- = 0xff; 4894 } 4895 4896 *dp-- = *sp--; 4897 *dp-- = *sp--; 4898 *dp-- = *sp--; 4899 *dp-- = *sp--; 4900 *dp-- = *sp--; 4901 *dp-- = *sp--; 4902 } 4903 } 4904 row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; 4905 row_info->channels = 4; 4906 row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); 4907 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); 4908 } 4909 } 4910 } 4911 #endif 4912 4913 #ifdef PNG_READ_EXPAND_16_SUPPORTED 4914 /* If the bit depth is 8 and the color type is not a palette type expand the 4915 * whole row to 16 bits. Has no effect otherwise. 4916 */ 4917 void /* PRIVATE */ 4918 png_do_expand_16(png_row_infop row_info, png_bytep row) 4919 { 4920 if (row_info->bit_depth == 8 && 4921 row_info->color_type != PNG_COLOR_TYPE_PALETTE) 4922 { 4923 /* The row have a sequence of bytes containing [0..255] and we need 4924 * to turn it into another row containing [0..65535], to do this we 4925 * calculate: 4926 * 4927 * (input / 255) * 65535 4928 * 4929 * Which happens to be exactly input * 257 and this can be achieved 4930 * simply by byte replication in place (copying backwards). 4931 */ 4932 png_byte *sp = row + row_info->rowbytes; /* source, last byte + 1 */ 4933 png_byte *dp = sp + row_info->rowbytes; /* destination, end + 1 */ 4934 while (dp > sp) 4935 dp[-2] = dp[-1] = *--sp, dp -= 2; 4936 4937 row_info->rowbytes *= 2; 4938 row_info->bit_depth = 16; 4939 row_info->pixel_depth = (png_byte)(row_info->channels * 16); 4940 } 4941 } 4942 #endif 4943 4944 #ifdef PNG_READ_QUANTIZE_SUPPORTED 4945 void /* PRIVATE */ 4946 png_do_quantize(png_row_infop row_info, png_bytep row, 4947 png_const_bytep palette_lookup, png_const_bytep quantize_lookup) 4948 { 4949 png_bytep sp, dp; 4950 png_uint_32 i; 4951 png_uint_32 row_width=row_info->width; 4952 4953 png_debug(1, "in png_do_quantize"); 4954 4955 if (row_info->bit_depth == 8) 4956 { 4957 if (row_info->color_type == PNG_COLOR_TYPE_RGB && palette_lookup) 4958 { 4959 int r, g, b, p; 4960 sp = row; 4961 dp = row; 4962 for (i = 0; i < row_width; i++) 4963 { 4964 r = *sp++; 4965 g = *sp++; 4966 b = *sp++; 4967 4968 /* This looks real messy, but the compiler will reduce 4969 * it down to a reasonable formula. For example, with 4970 * 5 bits per color, we get: 4971 * p = (((r >> 3) & 0x1f) << 10) | 4972 * (((g >> 3) & 0x1f) << 5) | 4973 * ((b >> 3) & 0x1f); 4974 */ 4975 p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) & 4976 ((1 << PNG_QUANTIZE_RED_BITS) - 1)) << 4977 (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | 4978 (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & 4979 ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << 4980 (PNG_QUANTIZE_BLUE_BITS)) | 4981 ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & 4982 ((1 << PNG_QUANTIZE_BLUE_BITS) - 1)); 4983 4984 *dp++ = palette_lookup[p]; 4985 } 4986 4987 row_info->color_type = PNG_COLOR_TYPE_PALETTE; 4988 row_info->channels = 1; 4989 row_info->pixel_depth = row_info->bit_depth; 4990 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); 4991 } 4992 4993 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && 4994 palette_lookup != NULL) 4995 { 4996 int r, g, b, p; 4997 sp = row; 4998 dp = row; 4999 for (i = 0; i < row_width; i++) 5000 { 5001 r = *sp++; 5002 g = *sp++; 5003 b = *sp++; 5004 sp++; 5005 5006 p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) & 5007 ((1 << PNG_QUANTIZE_RED_BITS) - 1)) << 5008 (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | 5009 (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & 5010 ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << 5011 (PNG_QUANTIZE_BLUE_BITS)) | 5012 ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & 5013 ((1 << PNG_QUANTIZE_BLUE_BITS) - 1)); 5014 5015 *dp++ = palette_lookup[p]; 5016 } 5017 5018 row_info->color_type = PNG_COLOR_TYPE_PALETTE; 5019 row_info->channels = 1; 5020 row_info->pixel_depth = row_info->bit_depth; 5021 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); 5022 } 5023 5024 else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && 5025 quantize_lookup) 5026 { 5027 sp = row; 5028 5029 for (i = 0; i < row_width; i++, sp++) 5030 { 5031 *sp = quantize_lookup[*sp]; 5032 } 5033 } 5034 } 5035 } 5036 #endif /* PNG_READ_QUANTIZE_SUPPORTED */ 5037 #endif /* PNG_READ_TRANSFORMS_SUPPORTED */ 5038 5039 #ifdef PNG_MNG_FEATURES_SUPPORTED 5040 /* Undoes intrapixel differencing */ 5041 void /* PRIVATE */ 5042 png_do_read_intrapixel(png_row_infop row_info, png_bytep row) 5043 { 5044 png_debug(1, "in png_do_read_intrapixel"); 5045 5046 if ( 5047 (row_info->color_type & PNG_COLOR_MASK_COLOR)) 5048 { 5049 int bytes_per_pixel; 5050 png_uint_32 row_width = row_info->width; 5051 5052 if (row_info->bit_depth == 8) 5053 { 5054 png_bytep rp; 5055 png_uint_32 i; 5056 5057 if (row_info->color_type == PNG_COLOR_TYPE_RGB) 5058 bytes_per_pixel = 3; 5059 5060 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 5061 bytes_per_pixel = 4; 5062 5063 else 5064 return; 5065 5066 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) 5067 { 5068 *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff); 5069 *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff); 5070 } 5071 } 5072 else if (row_info->bit_depth == 16) 5073 { 5074 png_bytep rp; 5075 png_uint_32 i; 5076 5077 if (row_info->color_type == PNG_COLOR_TYPE_RGB) 5078 bytes_per_pixel = 6; 5079 5080 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 5081 bytes_per_pixel = 8; 5082 5083 else 5084 return; 5085 5086 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) 5087 { 5088 png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1); 5089 png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3); 5090 png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5); 5091 png_uint_32 red = (s0 + s1 + 65536) & 0xffff; 5092 png_uint_32 blue = (s2 + s1 + 65536) & 0xffff; 5093 *(rp ) = (png_byte)((red >> 8) & 0xff); 5094 *(rp + 1) = (png_byte)(red & 0xff); 5095 *(rp + 4) = (png_byte)((blue >> 8) & 0xff); 5096 *(rp + 5) = (png_byte)(blue & 0xff); 5097 } 5098 } 5099 } 5100 } 5101 #endif /* PNG_MNG_FEATURES_SUPPORTED */ 5102 #endif /* PNG_READ_SUPPORTED */ 5103
