1 2 /* pngwtran.c - transforms the data in a row for PNG writers 3 * 4 * Last changed in libpng 1.6.9 [February 6, 2014] 5 * Copyright (c) 1998-2014 Glenn Randers-Pehrson 6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 8 * 9 * This code is released under the libpng license. 10 * For conditions of distribution and use, see the disclaimer 11 * and license in png.h 12 */ 13 14 #include "pngpriv.h" 15 16 #ifdef PNG_WRITE_SUPPORTED 17 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED 18 19 #ifdef PNG_WRITE_PACK_SUPPORTED 20 /* Pack pixels into bytes. Pass the true bit depth in bit_depth. The 21 * row_info bit depth should be 8 (one pixel per byte). The channels 22 * should be 1 (this only happens on grayscale and paletted images). 23 */ 24 static void 25 png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) 26 { 27 png_debug(1, "in png_do_pack"); 28 29 if (row_info->bit_depth == 8 && 30 row_info->channels == 1) 31 { 32 switch ((int)bit_depth) 33 { 34 case 1: 35 { 36 png_bytep sp, dp; 37 int mask, v; 38 png_uint_32 i; 39 png_uint_32 row_width = row_info->width; 40 41 sp = row; 42 dp = row; 43 mask = 0x80; 44 v = 0; 45 46 for (i = 0; i < row_width; i++) 47 { 48 if (*sp != 0) 49 v |= mask; 50 51 sp++; 52 53 if (mask > 1) 54 mask >>= 1; 55 56 else 57 { 58 mask = 0x80; 59 *dp = (png_byte)v; 60 dp++; 61 v = 0; 62 } 63 } 64 65 if (mask != 0x80) 66 *dp = (png_byte)v; 67 68 break; 69 } 70 71 case 2: 72 { 73 png_bytep sp, dp; 74 int shift, v; 75 png_uint_32 i; 76 png_uint_32 row_width = row_info->width; 77 78 sp = row; 79 dp = row; 80 shift = 6; 81 v = 0; 82 83 for (i = 0; i < row_width; i++) 84 { 85 png_byte value; 86 87 value = (png_byte)(*sp & 0x03); 88 v |= (value << shift); 89 90 if (shift == 0) 91 { 92 shift = 6; 93 *dp = (png_byte)v; 94 dp++; 95 v = 0; 96 } 97 98 else 99 shift -= 2; 100 101 sp++; 102 } 103 104 if (shift != 6) 105 *dp = (png_byte)v; 106 107 break; 108 } 109 110 case 4: 111 { 112 png_bytep sp, dp; 113 int shift, v; 114 png_uint_32 i; 115 png_uint_32 row_width = row_info->width; 116 117 sp = row; 118 dp = row; 119 shift = 4; 120 v = 0; 121 122 for (i = 0; i < row_width; i++) 123 { 124 png_byte value; 125 126 value = (png_byte)(*sp & 0x0f); 127 v |= (value << shift); 128 129 if (shift == 0) 130 { 131 shift = 4; 132 *dp = (png_byte)v; 133 dp++; 134 v = 0; 135 } 136 137 else 138 shift -= 4; 139 140 sp++; 141 } 142 143 if (shift != 4) 144 *dp = (png_byte)v; 145 146 break; 147 } 148 149 default: 150 break; 151 } 152 153 row_info->bit_depth = (png_byte)bit_depth; 154 row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); 155 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, 156 row_info->width); 157 } 158 } 159 #endif 160 161 #ifdef PNG_WRITE_SHIFT_SUPPORTED 162 /* Shift pixel values to take advantage of whole range. Pass the 163 * true number of bits in bit_depth. The row should be packed 164 * according to row_info->bit_depth. Thus, if you had a row of 165 * bit depth 4, but the pixels only had values from 0 to 7, you 166 * would pass 3 as bit_depth, and this routine would translate the 167 * data to 0 to 15. 168 */ 169 static void 170 png_do_shift(png_row_infop row_info, png_bytep row, 171 png_const_color_8p bit_depth) 172 { 173 png_debug(1, "in png_do_shift"); 174 175 if (row_info->color_type != PNG_COLOR_TYPE_PALETTE) 176 { 177 int shift_start[4], shift_dec[4]; 178 int channels = 0; 179 180 if (row_info->color_type & PNG_COLOR_MASK_COLOR) 181 { 182 shift_start[channels] = row_info->bit_depth - bit_depth->red; 183 shift_dec[channels] = bit_depth->red; 184 channels++; 185 186 shift_start[channels] = row_info->bit_depth - bit_depth->green; 187 shift_dec[channels] = bit_depth->green; 188 channels++; 189 190 shift_start[channels] = row_info->bit_depth - bit_depth->blue; 191 shift_dec[channels] = bit_depth->blue; 192 channels++; 193 } 194 195 else 196 { 197 shift_start[channels] = row_info->bit_depth - bit_depth->gray; 198 shift_dec[channels] = bit_depth->gray; 199 channels++; 200 } 201 202 if (row_info->color_type & PNG_COLOR_MASK_ALPHA) 203 { 204 shift_start[channels] = row_info->bit_depth - bit_depth->alpha; 205 shift_dec[channels] = bit_depth->alpha; 206 channels++; 207 } 208 209 /* With low row depths, could only be grayscale, so one channel */ 210 if (row_info->bit_depth < 8) 211 { 212 png_bytep bp = row; 213 png_size_t i; 214 unsigned int mask; 215 png_size_t row_bytes = row_info->rowbytes; 216 217 if (bit_depth->gray == 1 && row_info->bit_depth == 2) 218 mask = 0x55; 219 220 else if (row_info->bit_depth == 4 && bit_depth->gray == 3) 221 mask = 0x11; 222 223 else 224 mask = 0xff; 225 226 for (i = 0; i < row_bytes; i++, bp++) 227 { 228 int j; 229 unsigned int v, out; 230 231 v = *bp; 232 out = 0; 233 234 for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0]) 235 { 236 if (j > 0) 237 out |= v << j; 238 239 else 240 out |= (v >> (-j)) & mask; 241 } 242 243 *bp = (png_byte)(out & 0xff); 244 } 245 } 246 247 else if (row_info->bit_depth == 8) 248 { 249 png_bytep bp = row; 250 png_uint_32 i; 251 png_uint_32 istop = channels * row_info->width; 252 253 for (i = 0; i < istop; i++, bp++) 254 { 255 256 const unsigned int c = i%channels; 257 int j; 258 unsigned int v, out; 259 260 v = *bp; 261 out = 0; 262 263 for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) 264 { 265 if (j > 0) 266 out |= v << j; 267 268 else 269 out |= v >> (-j); 270 } 271 272 *bp = (png_byte)(out & 0xff); 273 } 274 } 275 276 else 277 { 278 png_bytep bp; 279 png_uint_32 i; 280 png_uint_32 istop = channels * row_info->width; 281 282 for (bp = row, i = 0; i < istop; i++) 283 { 284 const unsigned int c = i%channels; 285 int j; 286 unsigned int value, v; 287 288 v = png_get_uint_16(bp); 289 value = 0; 290 291 for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) 292 { 293 if (j > 0) 294 value |= v << j; 295 296 else 297 value |= v >> (-j); 298 } 299 *bp++ = (png_byte)((value >> 8) & 0xff); 300 *bp++ = (png_byte)(value & 0xff); 301 } 302 } 303 } 304 } 305 #endif 306 307 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED 308 static void 309 png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) 310 { 311 png_debug(1, "in png_do_write_swap_alpha"); 312 313 { 314 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 315 { 316 if (row_info->bit_depth == 8) 317 { 318 /* This converts from ARGB to RGBA */ 319 png_bytep sp, dp; 320 png_uint_32 i; 321 png_uint_32 row_width = row_info->width; 322 323 for (i = 0, sp = dp = row; i < row_width; i++) 324 { 325 png_byte save = *(sp++); 326 *(dp++) = *(sp++); 327 *(dp++) = *(sp++); 328 *(dp++) = *(sp++); 329 *(dp++) = save; 330 } 331 } 332 333 #ifdef PNG_WRITE_16BIT_SUPPORTED 334 else 335 { 336 /* This converts from AARRGGBB to RRGGBBAA */ 337 png_bytep sp, dp; 338 png_uint_32 i; 339 png_uint_32 row_width = row_info->width; 340 341 for (i = 0, sp = dp = row; i < row_width; i++) 342 { 343 png_byte save[2]; 344 save[0] = *(sp++); 345 save[1] = *(sp++); 346 *(dp++) = *(sp++); 347 *(dp++) = *(sp++); 348 *(dp++) = *(sp++); 349 *(dp++) = *(sp++); 350 *(dp++) = *(sp++); 351 *(dp++) = *(sp++); 352 *(dp++) = save[0]; 353 *(dp++) = save[1]; 354 } 355 } 356 #endif /* PNG_WRITE_16BIT_SUPPORTED */ 357 } 358 359 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) 360 { 361 if (row_info->bit_depth == 8) 362 { 363 /* This converts from AG to GA */ 364 png_bytep sp, dp; 365 png_uint_32 i; 366 png_uint_32 row_width = row_info->width; 367 368 for (i = 0, sp = dp = row; i < row_width; i++) 369 { 370 png_byte save = *(sp++); 371 *(dp++) = *(sp++); 372 *(dp++) = save; 373 } 374 } 375 376 #ifdef PNG_WRITE_16BIT_SUPPORTED 377 else 378 { 379 /* This converts from AAGG to GGAA */ 380 png_bytep sp, dp; 381 png_uint_32 i; 382 png_uint_32 row_width = row_info->width; 383 384 for (i = 0, sp = dp = row; i < row_width; i++) 385 { 386 png_byte save[2]; 387 save[0] = *(sp++); 388 save[1] = *(sp++); 389 *(dp++) = *(sp++); 390 *(dp++) = *(sp++); 391 *(dp++) = save[0]; 392 *(dp++) = save[1]; 393 } 394 } 395 #endif /* PNG_WRITE_16BIT_SUPPORTED */ 396 } 397 } 398 } 399 #endif 400 401 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED 402 static void 403 png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) 404 { 405 png_debug(1, "in png_do_write_invert_alpha"); 406 407 { 408 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 409 { 410 if (row_info->bit_depth == 8) 411 { 412 /* This inverts the alpha channel in RGBA */ 413 png_bytep sp, dp; 414 png_uint_32 i; 415 png_uint_32 row_width = row_info->width; 416 417 for (i = 0, sp = dp = row; i < row_width; i++) 418 { 419 /* Does nothing 420 *(dp++) = *(sp++); 421 *(dp++) = *(sp++); 422 *(dp++) = *(sp++); 423 */ 424 sp+=3; dp = sp; 425 *(dp++) = (png_byte)(255 - *(sp++)); 426 } 427 } 428 429 #ifdef PNG_WRITE_16BIT_SUPPORTED 430 else 431 { 432 /* This inverts the alpha channel in RRGGBBAA */ 433 png_bytep sp, dp; 434 png_uint_32 i; 435 png_uint_32 row_width = row_info->width; 436 437 for (i = 0, sp = dp = row; i < row_width; i++) 438 { 439 /* Does nothing 440 *(dp++) = *(sp++); 441 *(dp++) = *(sp++); 442 *(dp++) = *(sp++); 443 *(dp++) = *(sp++); 444 *(dp++) = *(sp++); 445 *(dp++) = *(sp++); 446 */ 447 sp+=6; dp = sp; 448 *(dp++) = (png_byte)(255 - *(sp++)); 449 *(dp++) = (png_byte)(255 - *(sp++)); 450 } 451 } 452 #endif /* PNG_WRITE_16BIT_SUPPORTED */ 453 } 454 455 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) 456 { 457 if (row_info->bit_depth == 8) 458 { 459 /* This inverts the alpha channel in GA */ 460 png_bytep sp, dp; 461 png_uint_32 i; 462 png_uint_32 row_width = row_info->width; 463 464 for (i = 0, sp = dp = row; i < row_width; i++) 465 { 466 *(dp++) = *(sp++); 467 *(dp++) = (png_byte)(255 - *(sp++)); 468 } 469 } 470 471 #ifdef PNG_WRITE_16BIT_SUPPORTED 472 else 473 { 474 /* This inverts the alpha channel in GGAA */ 475 png_bytep sp, dp; 476 png_uint_32 i; 477 png_uint_32 row_width = row_info->width; 478 479 for (i = 0, sp = dp = row; i < row_width; i++) 480 { 481 /* Does nothing 482 *(dp++) = *(sp++); 483 *(dp++) = *(sp++); 484 */ 485 sp+=2; dp = sp; 486 *(dp++) = (png_byte)(255 - *(sp++)); 487 *(dp++) = (png_byte)(255 - *(sp++)); 488 } 489 } 490 #endif /* PNG_WRITE_16BIT_SUPPORTED */ 491 } 492 } 493 } 494 #endif 495 496 /* Transform the data according to the user's wishes. The order of 497 * transformations is significant. 498 */ 499 void /* PRIVATE */ 500 png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info) 501 { 502 png_debug(1, "in png_do_write_transformations"); 503 504 if (png_ptr == NULL) 505 return; 506 507 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED 508 if (png_ptr->transformations & PNG_USER_TRANSFORM) 509 if (png_ptr->write_user_transform_fn != NULL) 510 (*(png_ptr->write_user_transform_fn)) /* User write transform 511 function */ 512 (png_ptr, /* png_ptr */ 513 row_info, /* row_info: */ 514 /* png_uint_32 width; width of row */ 515 /* png_size_t rowbytes; number of bytes in row */ 516 /* png_byte color_type; color type of pixels */ 517 /* png_byte bit_depth; bit depth of samples */ 518 /* png_byte channels; number of channels (1-4) */ 519 /* png_byte pixel_depth; bits per pixel (depth*channels) */ 520 png_ptr->row_buf + 1); /* start of pixel data for row */ 521 #endif 522 523 #ifdef PNG_WRITE_FILLER_SUPPORTED 524 if (png_ptr->transformations & PNG_FILLER) 525 png_do_strip_channel(row_info, png_ptr->row_buf + 1, 526 !(png_ptr->flags & PNG_FLAG_FILLER_AFTER)); 527 #endif 528 529 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED 530 if (png_ptr->transformations & PNG_PACKSWAP) 531 png_do_packswap(row_info, png_ptr->row_buf + 1); 532 #endif 533 534 #ifdef PNG_WRITE_PACK_SUPPORTED 535 if (png_ptr->transformations & PNG_PACK) 536 png_do_pack(row_info, png_ptr->row_buf + 1, 537 (png_uint_32)png_ptr->bit_depth); 538 #endif 539 540 #ifdef PNG_WRITE_SWAP_SUPPORTED 541 if (png_ptr->transformations & PNG_SWAP_BYTES) 542 png_do_swap(row_info, png_ptr->row_buf + 1); 543 #endif 544 545 #ifdef PNG_WRITE_SHIFT_SUPPORTED 546 if (png_ptr->transformations & PNG_SHIFT) 547 png_do_shift(row_info, png_ptr->row_buf + 1, 548 &(png_ptr->shift)); 549 #endif 550 551 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED 552 if (png_ptr->transformations & PNG_SWAP_ALPHA) 553 png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1); 554 #endif 555 556 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED 557 if (png_ptr->transformations & PNG_INVERT_ALPHA) 558 png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1); 559 #endif 560 561 #ifdef PNG_WRITE_BGR_SUPPORTED 562 if (png_ptr->transformations & PNG_BGR) 563 png_do_bgr(row_info, png_ptr->row_buf + 1); 564 #endif 565 566 #ifdef PNG_WRITE_INVERT_SUPPORTED 567 if (png_ptr->transformations & PNG_INVERT_MONO) 568 png_do_invert(row_info, png_ptr->row_buf + 1); 569 #endif 570 } 571 #endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ 572 #endif /* PNG_WRITE_SUPPORTED */ 573
