workbench/libs/png/pngwtran.c

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