src/png/pngwtran.c

   1
   2 /* pngwtran.c - transforms the data in a row for PNG writers
   3  *
   4  * libpng 1.2.4 - July 8, 2002
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1998-2002 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\n");
  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_INVERT_ALPHA_SUPPORTED)
  64    if (png_ptr->transformations & PNG_INVERT_ALPHA)
  65       png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
  66 #endif
  67 #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  68    if (png_ptr->transformations & PNG_SWAP_ALPHA)
  69       png_do_write_swap_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\n");
  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 =
 199          ((row_info->width * row_info->pixel_depth + 7) >> 3);
 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\n");
 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\n");
 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\n");
 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                *(dp++) = *(sp++);
 443                *(dp++) = *(sp++);
 444                *(dp++) = *(sp++);
 445                *(dp++) = (png_byte)(255 - *(sp++));
 446             }
 447          }
 448          /* This inverts the alpha channel in RRGGBBAA */
 449          else
 450          {
 451             png_bytep sp, dp;
 452             png_uint_32 i;
 453             png_uint_32 row_width = row_info->width;
 454
 455             for (i = 0, sp = dp = row; i < row_width; i++)
 456             {
 457                *(dp++) = *(sp++);
 458                *(dp++) = *(sp++);
 459                *(dp++) = *(sp++);
 460                *(dp++) = *(sp++);
 461                *(dp++) = *(sp++);
 462                *(dp++) = *(sp++);
 463                *(dp++) = (png_byte)(255 - *(sp++));
 464                *(dp++) = (png_byte)(255 - *(sp++));
 465             }
 466          }
 467       }
 468       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 469       {
 470          /* This inverts the alpha channel in GA */
 471          if (row_info->bit_depth == 8)
 472          {
 473             png_bytep sp, dp;
 474             png_uint_32 i;
 475             png_uint_32 row_width = row_info->width;
 476
 477             for (i = 0, sp = dp = row; i < row_width; i++)
 478             {
 479                *(dp++) = *(sp++);
 480                *(dp++) = (png_byte)(255 - *(sp++));
 481             }
 482          }
 483          /* This inverts the alpha channel in GGAA */
 484          else
 485          {
 486             png_bytep sp, dp;
 487             png_uint_32 i;
 488             png_uint_32 row_width = row_info->width;
 489
 490             for (i = 0, sp = dp = row; i < row_width; i++)
 491             {
 492                *(dp++) = *(sp++);
 493                *(dp++) = *(sp++);
 494                *(dp++) = (png_byte)(255 - *(sp++));
 495                *(dp++) = (png_byte)(255 - *(sp++));
 496             }
 497          }
 498       }
 499    }
 500 }
 501 #endif
 502
 503 #if defined(PNG_MNG_FEATURES_SUPPORTED)
 504 /* undoes intrapixel differencing  */
 505 void /* PRIVATE */
 506 png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
 507 {
 508    png_debug(1, "in png_do_write_intrapixel\n");
 509    if (
 510 #if defined(PNG_USELESS_TESTS_SUPPORTED)
 511        row != NULL && row_info != NULL &&
 512 #endif
 513        (row_info->color_type & PNG_COLOR_MASK_COLOR))
 514    {
 515       int bytes_per_pixel;
 516       png_uint_32 row_width = row_info->width;
 517       if (row_info->bit_depth == 8)
 518       {
 519          png_bytep rp;
 520          png_uint_32 i;
 521
 522          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 523             bytes_per_pixel = 3;
 524          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 525             bytes_per_pixel = 4;
 526          else
 527             return;
 528
 529          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
 530          {
 531             *(rp)   = (png_byte)((*rp     - *(rp+1))&0xff);
 532             *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);
 533          }
 534       }
 535       else if (row_info->bit_depth == 16)
 536       {
 537          png_bytep rp;
 538          png_uint_32 i;
 539
 540          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
 541             bytes_per_pixel = 6;
 542          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 543             bytes_per_pixel = 8;
 544          else
 545             return;
 546
 547          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
 548          {
 549             png_uint_32 s0=*(rp  )<<8 | *(rp+1);
 550             png_uint_32 s1=*(rp+2)<<8 | *(rp+3);
 551             png_uint_32 s2=*(rp+4)<<8 | *(rp+5);
 552             png_uint_32 red=(s0-s1)&0xffff;
 553             png_uint_32 blue=(s2-s1)&0xffff;
 554             *(rp  ) = (png_byte)((red>>8)&0xff);
 555             *(rp+1) = (png_byte)(red&0xff);
 556             *(rp+4) = (png_byte)((blue>>8)&0xff);
 557             *(rp+5) = (png_byte)(blue&0xff);
 558          }
 559       }
 560    }
 561 }
 562 #endif /* PNG_MNG_FEATURES_SUPPORTED */
 563 #endif /* PNG_WRITE_SUPPORTED */