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