"Fossies" - the Fresh Open Source Software Archive

Member "pngcrush-1.8.13/pngtrans.c" (29 Aug 2017, 25324 Bytes) of package /linux/privat/pngcrush-1.8.13.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "pngtrans.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 1.8.11_vs_1.8.12.

    1 
    2 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
    3  *
    4  * Last changed in libpng 1.6.30 [June 28, 2017]
    5  * Copyright (c) 1998-2002,2004,2006-2017 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 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
   17 
   18 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
   19 /* Turn on BGR-to-RGB mapping */
   20 void PNGAPI
   21 png_set_bgr(png_structrp png_ptr)
   22 {
   23    png_debug(1, "in png_set_bgr");
   24 
   25    if (png_ptr == NULL)
   26       return;
   27 
   28    png_ptr->transformations |= PNG_BGR;
   29 }
   30 #endif
   31 
   32 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
   33 /* Turn on 16-bit byte swapping */
   34 void PNGAPI
   35 png_set_swap(png_structrp png_ptr)
   36 {
   37    png_debug(1, "in png_set_swap");
   38 
   39    if (png_ptr == NULL)
   40       return;
   41 
   42    if (png_ptr->bit_depth == 16)
   43       png_ptr->transformations |= PNG_SWAP_BYTES;
   44 }
   45 #endif
   46 
   47 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
   48 /* Turn on pixel packing */
   49 void PNGAPI
   50 png_set_packing(png_structrp png_ptr)
   51 {
   52    png_debug(1, "in png_set_packing");
   53 
   54    if (png_ptr == NULL)
   55       return;
   56 
   57    if (png_ptr->bit_depth < 8)
   58    {
   59       png_ptr->transformations |= PNG_PACK;
   60 #     ifdef PNG_WRITE_SUPPORTED
   61          png_ptr->usr_bit_depth = 8;
   62 #     endif
   63    }
   64 }
   65 #endif
   66 
   67 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
   68 /* Turn on packed pixel swapping */
   69 void PNGAPI
   70 png_set_packswap(png_structrp png_ptr)
   71 {
   72    png_debug(1, "in png_set_packswap");
   73 
   74    if (png_ptr == NULL)
   75       return;
   76 
   77    if (png_ptr->bit_depth < 8)
   78       png_ptr->transformations |= PNG_PACKSWAP;
   79 }
   80 #endif
   81 
   82 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
   83 void PNGAPI
   84 png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits)
   85 {
   86    png_debug(1, "in png_set_shift");
   87 
   88    if (png_ptr == NULL)
   89       return;
   90 
   91    png_ptr->transformations |= PNG_SHIFT;
   92    png_ptr->shift = *true_bits;
   93 }
   94 #endif
   95 
   96 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
   97     defined(PNG_WRITE_INTERLACING_SUPPORTED)
   98 int PNGAPI
   99 png_set_interlace_handling(png_structrp png_ptr)
  100 {
  101    png_debug(1, "in png_set_interlace handling");
  102 
  103    if (png_ptr != 0 && png_ptr->interlaced != 0)
  104    {
  105       png_ptr->transformations |= PNG_INTERLACE;
  106       return (7);
  107    }
  108 
  109    return (1);
  110 }
  111 #endif
  112 
  113 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
  114 /* Add a filler byte on read, or remove a filler or alpha byte on write.
  115  * The filler type has changed in v0.95 to allow future 2-byte fillers
  116  * for 48-bit input data, as well as to avoid problems with some compilers
  117  * that don't like bytes as parameters.
  118  */
  119 void PNGAPI
  120 png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
  121 {
  122    png_debug(1, "in png_set_filler");
  123 
  124    if (png_ptr == NULL)
  125       return;
  126 
  127    /* In libpng 1.6 it is possible to determine whether this is a read or write
  128     * operation and therefore to do more checking here for a valid call.
  129     */
  130    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
  131    {
  132 #     ifdef PNG_READ_FILLER_SUPPORTED
  133          /* On read png_set_filler is always valid, regardless of the base PNG
  134           * format, because other transformations can give a format where the
  135           * filler code can execute (basically an 8 or 16-bit component RGB or G
  136           * format.)
  137           *
  138           * NOTE: usr_channels is not used by the read code!  (This has led to
  139           * confusion in the past.)  The filler is only used in the read code.
  140           */
  141          png_ptr->filler = (png_uint_16)filler;
  142 #     else
  143          png_app_error(png_ptr, "png_set_filler not supported on read");
  144          PNG_UNUSED(filler) /* not used in the write case */
  145          return;
  146 #     endif
  147    }
  148 
  149    else /* write */
  150    {
  151 #     ifdef PNG_WRITE_FILLER_SUPPORTED
  152          /* On write the usr_channels parameter must be set correctly at the
  153           * start to record the number of channels in the app-supplied data.
  154           */
  155          switch (png_ptr->color_type)
  156          {
  157             case PNG_COLOR_TYPE_RGB:
  158                png_ptr->usr_channels = 4;
  159                break;
  160 
  161             case PNG_COLOR_TYPE_GRAY:
  162                if (png_ptr->bit_depth >= 8)
  163                {
  164                   png_ptr->usr_channels = 2;
  165                   break;
  166                }
  167 
  168                else
  169                {
  170                   /* There simply isn't any code in libpng to strip out bits
  171                    * from bytes when the components are less than a byte in
  172                    * size!
  173                    */
  174                   png_app_error(png_ptr,
  175                       "png_set_filler is invalid for"
  176                       " low bit depth gray output");
  177                   return;
  178                }
  179 
  180             default:
  181                png_app_error(png_ptr,
  182                    "png_set_filler: inappropriate color type");
  183                return;
  184          }
  185 #     else
  186          png_app_error(png_ptr, "png_set_filler not supported on write");
  187          return;
  188 #     endif
  189    }
  190 
  191    /* Here on success - libpng supports the operation, set the transformation
  192     * and the flag to say where the filler channel is.
  193     */
  194    png_ptr->transformations |= PNG_FILLER;
  195 
  196    if (filler_loc == PNG_FILLER_AFTER)
  197       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
  198 
  199    else
  200       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
  201 }
  202 
  203 /* Added to libpng-1.2.7 */
  204 void PNGAPI
  205 png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
  206 {
  207    png_debug(1, "in png_set_add_alpha");
  208 
  209    if (png_ptr == NULL)
  210       return;
  211 
  212    png_set_filler(png_ptr, filler, filler_loc);
  213    /* The above may fail to do anything. */
  214    if ((png_ptr->transformations & PNG_FILLER) != 0)
  215       png_ptr->transformations |= PNG_ADD_ALPHA;
  216 }
  217 
  218 #endif
  219 
  220 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
  221     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  222 void PNGAPI
  223 png_set_swap_alpha(png_structrp png_ptr)
  224 {
  225    png_debug(1, "in png_set_swap_alpha");
  226 
  227    if (png_ptr == NULL)
  228       return;
  229 
  230    png_ptr->transformations |= PNG_SWAP_ALPHA;
  231 }
  232 #endif
  233 
  234 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
  235     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
  236 void PNGAPI
  237 png_set_invert_alpha(png_structrp png_ptr)
  238 {
  239    png_debug(1, "in png_set_invert_alpha");
  240 
  241    if (png_ptr == NULL)
  242       return;
  243 
  244    png_ptr->transformations |= PNG_INVERT_ALPHA;
  245 }
  246 #endif
  247 
  248 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
  249 void PNGAPI
  250 png_set_invert_mono(png_structrp png_ptr)
  251 {
  252    png_debug(1, "in png_set_invert_mono");
  253 
  254    if (png_ptr == NULL)
  255       return;
  256 
  257    png_ptr->transformations |= PNG_INVERT_MONO;
  258 }
  259 
  260 /* Invert monochrome grayscale data */
  261 void /* PRIVATE */
  262 png_do_invert(png_row_infop row_info, png_bytep row)
  263 {
  264    png_debug(1, "in png_do_invert");
  265 
  266   /* This test removed from libpng version 1.0.13 and 1.2.0:
  267    *   if (row_info->bit_depth == 1 &&
  268    */
  269    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
  270    {
  271       png_bytep rp = row;
  272       png_size_t i;
  273       png_size_t istop = row_info->rowbytes;
  274 
  275       for (i = 0; i < istop; i++)
  276       {
  277          *rp = (png_byte)(~(*rp));
  278          rp++;
  279       }
  280    }
  281 
  282    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
  283       row_info->bit_depth == 8)
  284    {
  285       png_bytep rp = row;
  286       png_size_t i;
  287       png_size_t istop = row_info->rowbytes;
  288 
  289       for (i = 0; i < istop; i += 2)
  290       {
  291          *rp = (png_byte)(~(*rp));
  292          rp += 2;
  293       }
  294    }
  295 
  296 #ifdef PNG_16BIT_SUPPORTED
  297    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
  298       row_info->bit_depth == 16)
  299    {
  300       png_bytep rp = row;
  301       png_size_t i;
  302       png_size_t istop = row_info->rowbytes;
  303 
  304       for (i = 0; i < istop; i += 4)
  305       {
  306          *rp = (png_byte)(~(*rp));
  307          *(rp + 1) = (png_byte)(~(*(rp + 1)));
  308          rp += 4;
  309       }
  310    }
  311 #endif
  312 }
  313 #endif
  314 
  315 #ifdef PNG_16BIT_SUPPORTED
  316 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  317 /* Swaps byte order on 16-bit depth images */
  318 void /* PRIVATE */
  319 png_do_swap(png_row_infop row_info, png_bytep row)
  320 {
  321    png_debug(1, "in png_do_swap");
  322 
  323    if (row_info->bit_depth == 16)
  324    {
  325       png_bytep rp = row;
  326       png_uint_32 i;
  327       png_uint_32 istop= row_info->width * row_info->channels;
  328 
  329       for (i = 0; i < istop; i++, rp += 2)
  330       {
  331 #ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
  332          /* Feature added to libpng-1.6.11 for testing purposes, not
  333           * enabled by default.
  334           */
  335          *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
  336 #else
  337          png_byte t = *rp;
  338          *rp = *(rp + 1);
  339          *(rp + 1) = t;
  340 #endif
  341       }
  342    }
  343 }
  344 #endif
  345 #endif
  346 
  347 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  348 static PNG_CONST png_byte onebppswaptable[256] = {
  349    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
  350    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
  351    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
  352    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
  353    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
  354    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
  355    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
  356    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
  357    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
  358    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
  359    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
  360    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
  361    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
  362    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
  363    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
  364    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
  365    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
  366    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
  367    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
  368    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
  369    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
  370    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
  371    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
  372    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
  373    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
  374    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
  375    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
  376    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
  377    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
  378    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
  379    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
  380    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
  381 };
  382 
  383 static PNG_CONST png_byte twobppswaptable[256] = {
  384    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
  385    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
  386    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
  387    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
  388    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
  389    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
  390    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
  391    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
  392    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
  393    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
  394    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
  395    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
  396    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
  397    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
  398    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
  399    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
  400    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
  401    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
  402    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
  403    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
  404    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
  405    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
  406    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
  407    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
  408    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
  409    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
  410    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
  411    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
  412    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
  413    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
  414    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
  415    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
  416 };
  417 
  418 static PNG_CONST png_byte fourbppswaptable[256] = {
  419    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
  420    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
  421    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
  422    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
  423    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
  424    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
  425    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
  426    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
  427    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
  428    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
  429    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
  430    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
  431    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
  432    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
  433    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
  434    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
  435    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
  436    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
  437    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
  438    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
  439    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
  440    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
  441    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
  442    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
  443    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
  444    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
  445    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
  446    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
  447    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
  448    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
  449    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
  450    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
  451 };
  452 
  453 /* Swaps pixel packing order within bytes */
  454 void /* PRIVATE */
  455 png_do_packswap(png_row_infop row_info, png_bytep row)
  456 {
  457    png_debug(1, "in png_do_packswap");
  458 
  459    if (row_info->bit_depth < 8)
  460    {
  461       png_bytep rp;
  462       png_const_bytep end, table;
  463 
  464       end = row + row_info->rowbytes;
  465 
  466       if (row_info->bit_depth == 1)
  467          table = onebppswaptable;
  468 
  469       else if (row_info->bit_depth == 2)
  470          table = twobppswaptable;
  471 
  472       else if (row_info->bit_depth == 4)
  473          table = fourbppswaptable;
  474 
  475       else
  476          return;
  477 
  478       for (rp = row; rp < end; rp++)
  479          *rp = table[*rp];
  480    }
  481 }
  482 #endif /* PACKSWAP || WRITE_PACKSWAP */
  483 
  484 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
  485     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  486 /* Remove a channel - this used to be 'png_do_strip_filler' but it used a
  487  * somewhat weird combination of flags to determine what to do.  All the calls
  488  * to png_do_strip_filler are changed in 1.5.2 to call this instead with the
  489  * correct arguments.
  490  *
  491  * The routine isn't general - the channel must be the channel at the start or
  492  * end (not in the middle) of each pixel.
  493  */
  494 void /* PRIVATE */
  495 png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
  496 {
  497    png_bytep sp = row; /* source pointer */
  498    png_bytep dp = row; /* destination pointer */
  499    png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
  500 
  501    /* At the start sp will point to the first byte to copy and dp to where
  502     * it is copied to.  ep always points just beyond the end of the row, so
  503     * the loop simply copies (channels-1) channels until sp reaches ep.
  504     *
  505     * at_start:        0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.
  506     *            nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.
  507     */
  508 
  509    /* GA, GX, XG cases */
  510    if (row_info->channels == 2)
  511    {
  512       if (row_info->bit_depth == 8)
  513       {
  514          if (at_start != 0) /* Skip initial filler */
  515             ++sp;
  516          else          /* Skip initial channel and, for sp, the filler */
  517          {
  518             sp += 2; ++dp;
  519          }
  520 
  521          /* For a 1 pixel wide image there is nothing to do */
  522          while (sp < ep)
  523          {
  524             *dp++ = *sp; sp += 2;
  525          }
  526 
  527          row_info->pixel_depth = 8;
  528       }
  529 
  530       else if (row_info->bit_depth == 16)
  531       {
  532          if (at_start != 0) /* Skip initial filler */
  533             sp += 2;
  534          else          /* Skip initial channel and, for sp, the filler */
  535          {
  536             sp += 4; dp += 2;
  537          }
  538 
  539          while (sp < ep)
  540          {
  541             *dp++ = *sp++; *dp++ = *sp; sp += 3;
  542          }
  543 
  544          row_info->pixel_depth = 16;
  545       }
  546 
  547       else
  548          return; /* bad bit depth */
  549 
  550       row_info->channels = 1;
  551 
  552       /* Finally fix the color type if it records an alpha channel */
  553       if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  554          row_info->color_type = PNG_COLOR_TYPE_GRAY;
  555    }
  556 
  557    /* RGBA, RGBX, XRGB cases */
  558    else if (row_info->channels == 4)
  559    {
  560       if (row_info->bit_depth == 8)
  561       {
  562          if (at_start != 0) /* Skip initial filler */
  563             ++sp;
  564          else          /* Skip initial channels and, for sp, the filler */
  565          {
  566             sp += 4; dp += 3;
  567          }
  568 
  569          /* Note that the loop adds 3 to dp and 4 to sp each time. */
  570          while (sp < ep)
  571          {
  572             *dp++ = *sp++; *dp++ = *sp++; *dp++ = *sp; sp += 2;
  573          }
  574 
  575          row_info->pixel_depth = 24;
  576       }
  577 
  578       else if (row_info->bit_depth == 16)
  579       {
  580          if (at_start != 0) /* Skip initial filler */
  581             sp += 2;
  582          else          /* Skip initial channels and, for sp, the filler */
  583          {
  584             sp += 8; dp += 6;
  585          }
  586 
  587          while (sp < ep)
  588          {
  589             /* Copy 6 bytes, skip 2 */
  590             *dp++ = *sp++; *dp++ = *sp++;
  591             *dp++ = *sp++; *dp++ = *sp++;
  592             *dp++ = *sp++; *dp++ = *sp; sp += 3;
  593          }
  594 
  595          row_info->pixel_depth = 48;
  596       }
  597 
  598       else
  599          return; /* bad bit depth */
  600 
  601       row_info->channels = 3;
  602 
  603       /* Finally fix the color type if it records an alpha channel */
  604       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  605          row_info->color_type = PNG_COLOR_TYPE_RGB;
  606    }
  607 
  608    else
  609       return; /* The filler channel has gone already */
  610 
  611    /* Fix the rowbytes value. */
  612    row_info->rowbytes = (unsigned int)(dp-row);
  613 }
  614 #endif
  615 
  616 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  617 /* Swaps red and blue bytes within a pixel */
  618 void /* PRIVATE */
  619 png_do_bgr(png_row_infop row_info, png_bytep row)
  620 {
  621    png_debug(1, "in png_do_bgr");
  622 
  623    if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
  624    {
  625       png_uint_32 row_width = row_info->width;
  626       if (row_info->bit_depth == 8)
  627       {
  628          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  629          {
  630             png_bytep rp;
  631             png_uint_32 i;
  632 
  633             for (i = 0, rp = row; i < row_width; i++, rp += 3)
  634             {
  635                png_byte save = *rp;
  636                *rp = *(rp + 2);
  637                *(rp + 2) = save;
  638             }
  639          }
  640 
  641          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  642          {
  643             png_bytep rp;
  644             png_uint_32 i;
  645 
  646             for (i = 0, rp = row; i < row_width; i++, rp += 4)
  647             {
  648                png_byte save = *rp;
  649                *rp = *(rp + 2);
  650                *(rp + 2) = save;
  651             }
  652          }
  653       }
  654 
  655 #ifdef PNG_16BIT_SUPPORTED
  656       else if (row_info->bit_depth == 16)
  657       {
  658          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  659          {
  660             png_bytep rp;
  661             png_uint_32 i;
  662 
  663             for (i = 0, rp = row; i < row_width; i++, rp += 6)
  664             {
  665                png_byte save = *rp;
  666                *rp = *(rp + 4);
  667                *(rp + 4) = save;
  668                save = *(rp + 1);
  669                *(rp + 1) = *(rp + 5);
  670                *(rp + 5) = save;
  671             }
  672          }
  673 
  674          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  675          {
  676             png_bytep rp;
  677             png_uint_32 i;
  678 
  679             for (i = 0, rp = row; i < row_width; i++, rp += 8)
  680             {
  681                png_byte save = *rp;
  682                *rp = *(rp + 4);
  683                *(rp + 4) = save;
  684                save = *(rp + 1);
  685                *(rp + 1) = *(rp + 5);
  686                *(rp + 5) = save;
  687             }
  688          }
  689       }
  690 #endif
  691    }
  692 }
  693 #endif /* READ_BGR || WRITE_BGR */
  694 
  695 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
  696     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
  697 /* Added at libpng-1.5.10 */
  698 void /* PRIVATE */
  699 png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
  700 {
  701    if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
  702       png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
  703    {
  704       /* Calculations moved outside switch in an attempt to stop different
  705        * compiler warnings.  'padding' is in *bits* within the last byte, it is
  706        * an 'int' because pixel_depth becomes an 'int' in the expression below,
  707        * and this calculation is used because it avoids warnings that other
  708        * forms produced on either GCC or MSVC.
  709        */
  710       int padding = PNG_PADBITS(row_info->pixel_depth, row_info->width);
  711       png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
  712 
  713       switch (row_info->bit_depth)
  714       {
  715          case 1:
  716          {
  717             /* in this case, all bytes must be 0 so we don't need
  718              * to unpack the pixels except for the rightmost one.
  719              */
  720             for (; rp > png_ptr->row_buf; rp--)
  721             {
  722               if ((*rp >> padding) != 0)
  723                  png_ptr->num_palette_max = 1;
  724               padding = 0;
  725             }
  726 
  727             break;
  728          }
  729 
  730          case 2:
  731          {
  732             for (; rp > png_ptr->row_buf; rp--)
  733             {
  734               int i = ((*rp >> padding) & 0x03);
  735 
  736               if (i > png_ptr->num_palette_max)
  737                  png_ptr->num_palette_max = i;
  738 
  739               i = (((*rp >> padding) >> 2) & 0x03);
  740 
  741               if (i > png_ptr->num_palette_max)
  742                  png_ptr->num_palette_max = i;
  743 
  744               i = (((*rp >> padding) >> 4) & 0x03);
  745 
  746               if (i > png_ptr->num_palette_max)
  747                  png_ptr->num_palette_max = i;
  748 
  749               i = (((*rp >> padding) >> 6) & 0x03);
  750 
  751               if (i > png_ptr->num_palette_max)
  752                  png_ptr->num_palette_max = i;
  753 
  754               padding = 0;
  755             }
  756 
  757             break;
  758          }
  759 
  760          case 4:
  761          {
  762             for (; rp > png_ptr->row_buf; rp--)
  763             {
  764               int i = ((*rp >> padding) & 0x0f);
  765 
  766               if (i > png_ptr->num_palette_max)
  767                  png_ptr->num_palette_max = i;
  768 
  769               i = (((*rp >> padding) >> 4) & 0x0f);
  770 
  771               if (i > png_ptr->num_palette_max)
  772                  png_ptr->num_palette_max = i;
  773 
  774               padding = 0;
  775             }
  776 
  777             break;
  778          }
  779 
  780          case 8:
  781          {
  782             for (; rp > png_ptr->row_buf; rp--)
  783             {
  784                if (*rp > png_ptr->num_palette_max)
  785                   png_ptr->num_palette_max = (int) *rp;
  786             }
  787 
  788             break;
  789          }
  790 
  791          default:
  792             break;
  793       }
  794    }
  795 }
  796 #endif /* CHECK_FOR_INVALID_INDEX */
  797 
  798 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
  799     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
  800 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
  801 void PNGAPI
  802 png_set_user_transform_info(png_structrp png_ptr, png_voidp
  803    user_transform_ptr, int user_transform_depth, int user_transform_channels)
  804 {
  805    png_debug(1, "in png_set_user_transform_info");
  806 
  807    if (png_ptr == NULL)
  808       return;
  809 
  810 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
  811    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
  812       (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
  813    {
  814       png_app_error(png_ptr,
  815           "info change after png_start_read_image or png_read_update_info");
  816       return;
  817    }
  818 #endif
  819 
  820    png_ptr->user_transform_ptr = user_transform_ptr;
  821    png_ptr->user_transform_depth = (png_byte)user_transform_depth;
  822    png_ptr->user_transform_channels = (png_byte)user_transform_channels;
  823 }
  824 #endif
  825 
  826 /* This function returns a pointer to the user_transform_ptr associated with
  827  * the user transform functions.  The application should free any memory
  828  * associated with this pointer before png_write_destroy and png_read_destroy
  829  * are called.
  830  */
  831 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
  832 png_voidp PNGAPI
  833 png_get_user_transform_ptr(png_const_structrp png_ptr)
  834 {
  835    if (png_ptr == NULL)
  836       return (NULL);
  837 
  838    return png_ptr->user_transform_ptr;
  839 }
  840 #endif
  841 
  842 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
  843 png_uint_32 PNGAPI
  844 png_get_current_row_number(png_const_structrp png_ptr)
  845 {
  846    /* See the comments in png.h - this is the sub-image row when reading an
  847     * interlaced image.
  848     */
  849    if (png_ptr != NULL)
  850       return png_ptr->row_number;
  851 
  852    return PNG_UINT_32_MAX; /* help the app not to fail silently */
  853 }
  854 
  855 png_byte PNGAPI
  856 png_get_current_pass_number(png_const_structrp png_ptr)
  857 {
  858    if (png_ptr != NULL)
  859       return png_ptr->pass;
  860    return 8; /* invalid */
  861 }
  862 #endif /* USER_TRANSFORM_INFO */
  863 #endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
  864 #endif /* READ || WRITE */