libs/png/pngwtran.c

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