src/libpng/pngwtran.c

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