/* pngtrans.c - transforms the data in a row (used by both readers and writers) * * Last changed in libpng 1.6.17 [(PENDING RELEASE)] * Copyright (c) 1998-2015 Glenn Randers-Pehrson * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * * This code is released under the libpng license. * For conditions of distribution and use, see the disclaimer * and license in png.h */ #include "pngpriv.h" #define PNG_SRC_FILE PNG_SRC_FILE_pngtrans #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) /* Turn on BGR-to-RGB mapping */ void PNGAPI png_set_bgr(png_structrp png_ptr) { png_debug(1, "in png_set_bgr"); if (png_ptr == NULL) return; png_ptr->transformations |= PNG_BGR; } #endif #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) /* Turn on 16 bit byte swapping */ void PNGAPI png_set_swap(png_structrp png_ptr) { png_debug(1, "in png_set_swap"); if (png_ptr == NULL) return; if (png_ptr->bit_depth == 16) png_ptr->transformations |= PNG_SWAP_BYTES; } #endif #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) /* Turn on pixel packing */ void PNGAPI png_set_packing(png_structrp png_ptr) { png_debug(1, "in png_set_packing"); if (png_ptr == NULL) return; if (png_ptr->bit_depth < 8) { png_ptr->transformations |= PNG_PACK; # ifdef PNG_WRITE_SUPPORTED png_ptr->usr_bit_depth = 8; # endif } } #endif #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) /* Turn on packed pixel swapping */ void PNGAPI png_set_packswap(png_structrp png_ptr) { png_debug(1, "in png_set_packswap"); if (png_ptr == NULL) return; if (png_ptr->bit_depth < 8) png_ptr->transformations |= PNG_PACKSWAP; } #endif #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) void PNGAPI png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits) { png_debug(1, "in png_set_shift"); if (png_ptr == NULL) return; png_ptr->transformations |= PNG_SHIFT; png_ptr->shift = *true_bits; } #endif #if defined(PNG_READ_INTERLACING_SUPPORTED) || \ defined(PNG_WRITE_INTERLACING_SUPPORTED) int PNGAPI png_set_interlace_handling(png_structrp png_ptr) { png_debug(1, "in png_set_interlace handling"); if (png_ptr != 0 && png_ptr->interlaced != 0) { png_ptr->transformations |= PNG_INTERLACE; return (7); } return (1); } #endif #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) /* Add a filler byte on read, or remove a filler or alpha byte on write. * The filler type has changed in v0.95 to allow future 2-byte fillers * for 48-bit input data, as well as to avoid problems with some compilers * that don't like bytes as parameters. */ void PNGAPI png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc) { png_debug(1, "in png_set_filler"); if (png_ptr == NULL) return; /* In libpng 1.6 it is possible to determine whether this is a read or write * operation and therefore to do more checking here for a valid call. */ if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0) { # ifdef PNG_READ_FILLER_SUPPORTED /* On read png_set_filler is always valid, regardless of the base PNG * format, because other transformations can give a format where the * filler code can execute (basically an 8 or 16-bit component RGB or G * format.) * * NOTE: usr_channels is not used by the read code! (This has led to * confusion in the past.) The filler is only used in the read code. */ png_ptr->filler = PNG_UINT_16(filler); /* Max bit depth is 16 */ # else png_app_error(png_ptr, "png_set_filler not supported on read"); PNG_UNUSED(filler) /* not used in the write case */ return; # endif } else /* write */ { # ifdef PNG_WRITE_FILLER_SUPPORTED /* On write the usr_channels parameter must be set correctly at the * start to record the number of channels in the app-supplied data. */ switch (png_ptr->color_type) { case PNG_COLOR_TYPE_RGB: png_ptr->usr_channels = 4; break; case PNG_COLOR_TYPE_GRAY: if (png_ptr->bit_depth >= 8) { png_ptr->usr_channels = 2; break; } else { /* There simply isn't any code in libpng to strip out bits * from bytes when the components are less than a byte in * size! */ png_app_error(png_ptr, "png_set_filler is invalid for low bit depth gray output"); return; } default: png_app_error(png_ptr, "png_set_filler: inappropriate color type"); return; } # else png_app_error(png_ptr, "png_set_filler not supported on write"); return; # endif } /* Here on success - libpng supports the operation, set the transformation * and the flag to say where the filler channel is. */ png_ptr->transformations |= PNG_FILLER; if (filler_loc == PNG_FILLER_AFTER) png_ptr->flags |= PNG_FLAG_FILLER_AFTER; else png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; } /* Added to libpng-1.2.7 */ void PNGAPI png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc) { png_debug(1, "in png_set_add_alpha"); if (png_ptr == NULL) return; png_set_filler(png_ptr, filler, filler_loc); /* The above may fail to do anything. */ if ((png_ptr->transformations & PNG_FILLER) != 0) png_ptr->transformations |= PNG_ADD_ALPHA; } #endif #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) void PNGAPI png_set_swap_alpha(png_structrp png_ptr) { png_debug(1, "in png_set_swap_alpha"); if (png_ptr == NULL) return; png_ptr->transformations |= PNG_SWAP_ALPHA; } #endif #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) void PNGAPI png_set_invert_alpha(png_structrp png_ptr) { png_debug(1, "in png_set_invert_alpha"); if (png_ptr == NULL) return; png_ptr->transformations |= PNG_INVERT_ALPHA; } #endif #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) void PNGAPI png_set_invert_mono(png_structrp png_ptr) { png_debug(1, "in png_set_invert_mono"); if (png_ptr == NULL) return; png_ptr->transformations |= PNG_INVERT_MONO; } /* Invert monochrome grayscale data */ void /* PRIVATE */ png_do_invert(png_transform_controlp row_info, png_bytep row) { png_debug(1, "in png_do_invert"); # define png_ptr row_info->png_ptr /* This test removed from libpng version 1.0.13 and 1.2.0: * if (row_info->bit_depth == 1 && */ if (row_info->channels == 1) { if (!(row_info->flags & PNG_INDEXED)) /* GRAY */ { png_bytep rp = row + png_transform_rowbytes(row_info); /* Don't care about the bit depth: */ while (rp > row) *--rp ^= 0xff; row_info->flags |= PNG_INVERTED; } } else if (row_info->channels == 2) /* GRAY ALPHA */ { if (row_info->bit_depth == 8) { png_bytep rp; row_info->flags |= PNG_INVERTED; rp = row + png_transform_rowbytes(row_info); /* Go backwards, so rp[-1] is alpha and rp[-2] is gray: */ while (rp >= row+2) rp -= 2, *rp ^= 0xff; } # ifdef PNG_16BIT_SUPPORTED else if (row_info->bit_depth == 16) { png_bytep rp; row_info->flags |= PNG_INVERTED; rp = row + png_transform_rowbytes(row_info); /* The same, but now we have GGAA: */ while (rp >= row+4) rp -= 3, *rp ^= 0xff, *--rp ^= 0xff; } # endif } # undef png_ptr } #endif /* READ_INVERT || WRITE_INVERT */ #ifdef PNG_16BIT_SUPPORTED #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) /* Swaps byte order on 16 bit depth images */ void /* PRIVATE */ png_do_swap(png_transform_controlp row_info, png_bytep row) { png_debug(1, "in png_do_swap"); # define png_ptr row_info->png_ptr if (row_info->bit_depth == 16) { png_bytep rp; row_info->flags |= PNG_BYTE_SWAPPED; rp = row + png_transform_rowbytes(row_info); while (rp >= row+2) { png_byte save = *--rp; *rp = rp[-1], --rp; *rp = save; } } # undef png_ptr } #endif /* READ_SWAP || WRITE_SWAP */ #endif /* 16_BIT */ #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) static PNG_CONST png_byte onebppswaptable[256] = { 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF }; static PNG_CONST png_byte twobppswaptable[256] = { 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0, 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4, 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4, 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8, 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8, 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC, 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC, 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1, 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1, 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5, 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5, 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9, 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9, 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD, 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD, 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2, 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2, 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6, 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6, 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA, 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA, 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE, 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE, 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3, 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3, 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7, 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7, 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB, 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB, 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF, 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF }; static PNG_CONST png_byte fourbppswaptable[256] = { 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1, 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2, 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73, 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3, 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74, 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4, 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5, 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76, 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6, 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7, 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8, 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9, 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A, 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA, 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B, 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB, 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC, 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D, 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD, 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E, 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE, 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F, 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF }; /* Swaps pixel packing order within bytes */ void /* PRIVATE */ png_do_packswap(png_transform_controlp row_info, png_bytep row) { png_debug(1, "in png_do_packswap"); # define png_ptr row_info->png_ptr if (row_info->bit_depth < 8) { png_bytep ep; png_const_bytep table; if (row_info->bit_depth == 1) table = onebppswaptable; else if (row_info->bit_depth == 2) table = twobppswaptable; else if (row_info->bit_depth == 4) table = fourbppswaptable; else return; row_info->flags |= PNG_PIXEL_SWAPPED; ep = row + png_transform_rowbytes(row_info); while (row < ep) *row = table[*row], ++row; } # undef png_ptr } #endif /* READ_PACKSWAP || WRITE_PACKSWAP */ #if defined(PNG_WRITE_FILLER_SUPPORTED) || \ defined(PNG_READ_STRIP_ALPHA_SUPPORTED) /* Remove a channel - this used to be 'png_do_strip_filler' but it used a * somewhat weird combination of flags to determine what to do. All the calls * to png_do_strip_filler are changed in 1.5.2 to call this instead with the * correct arguments. * * The routine isn't general - the channel must be the channel at the start or * end (not in the middle) of each pixel. */ void /* PRIVATE */ png_do_strip_channel(png_transform_controlp row_info, png_bytep row, int at_start) { png_const_bytep sp = row; /* source pointer */ png_bytep dp = row; /* destination pointer */ png_const_bytep ep = row + png_transform_rowbytes(row_info); /* beyond end */ # define png_ptr row_info->png_ptr /* At the start sp will point to the first byte to copy and dp to where * it is copied to. ep always points just beyond the end of the row, so * the loop simply copies (channels-1) channels until sp reaches ep. * * at_start: 0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc. * nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc. */ /* GA, GX, XG cases */ if (row_info->channels == 2) { if (row_info->bit_depth == 8) { if (at_start != 0) /* Skip initial filler */ ++sp; else /* Skip initial channel and, for sp, the filler */ sp += 2, ++dp; /* For a 1 pixel wide image there is nothing to do */ while (sp < ep) *dp++ = *sp, sp += 2; } else if (row_info->bit_depth == 16) { if (at_start != 0) /* Skip initial filler */ sp += 2; else /* Skip initial channel and, for sp, the filler */ sp += 4, dp += 2; while (sp < ep) *dp++ = *sp++, *dp++ = *sp, sp += 3; } else return; /* bad bit depth */ row_info->channels = 1; debug(dp == row + png_transform_rowbytes(row_info)); } /* RGBA, RGBX, XRGB cases */ else if (row_info->channels == 4) { if (row_info->bit_depth == 8) { if (at_start != 0) /* Skip initial filler */ ++sp; else /* Skip initial channels and, for sp, the filler */ sp += 4, dp += 3; /* Note that the loop adds 3 to dp and 4 to sp each time. */ while (sp < ep) *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2; } else if (row_info->bit_depth == 16) { if (at_start != 0) /* Skip initial filler */ sp += 2; else /* Skip initial channels and, for sp, the filler */ sp += 8, dp += 6; while (sp < ep) { /* Copy 6 bytes, skip 2 */ *dp++ = *sp++, *dp++ = *sp++; *dp++ = *sp++, *dp++ = *sp++; *dp++ = *sp++, *dp++ = *sp, sp += 3; } } else return; /* bad bit depth */ row_info->channels = 3; debug(dp == row + png_transform_rowbytes(row_info)); } else return; /* The filler channel has gone already */ # undef png_ptr } #endif /* WRITE_FILLER || READ_STRIP_ALPHA */ #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) /* Swaps red and blue bytes within a pixel */ void /* PRIVATE */ png_do_bgr(png_transform_controlp row_info, png_bytep row) { unsigned int channels; png_debug(1, "in png_do_bgr"); # define png_ptr row_info->png_ptr channels = row_info->channels; if (channels == 3 || channels == 4) { png_const_bytep ep = row + png_transform_rowbytes(row_info); if (row_info->bit_depth == 8) { ep -= channels; /* Last pixel */ row_info->flags ^= PNG_RGB_SWAPPED; while (row <= ep) { png_byte save = row[0]; row[0] = row[2]; row[2] = save; row += channels; } debug(row == ep+channels); } # ifdef PNG_16BIT_SUPPORTED else if (row_info->bit_depth == 16) { channels *= 2; /* now in bytes */ ep -= channels; /* Last pixel */ row_info->flags |= PNG_RGB_SWAPPED; while (row <= ep) { png_byte save = row[0]; row[0] = row[4]; row[4] = save; save = row[1]; row[1] = row[5]; row[5] = save; row += channels; } debug(row == ep+channels); } # endif } # undef png_ptr } #endif /* READ_BGR || WRITE_BGR */ #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) /* Added at libpng-1.5.10 */ void /* PRIVATE */ png_do_check_palette_indexes(png_structrp png_ptr, png_transform_controlp row_info) { if (png_ptr->num_palette < (1 << row_info->bit_depth) && png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */ { /* Padding is the unused bits in the last byte: 8 - bits-in-last-byte, * which reduces to 7 & (-total_bits), so we don't care about overflow * in the unsigned calculation here: */ unsigned int padding = 7 & -(row_info->bit_depth * row_info->channels * row_info->width); png_bytep rp = png_ptr->row_buf + png_transform_rowbytes(row_info); /* Note that png_ptr->row_buf starts with a filter byte, so rp is * currently pointing to the last byte in the row, not just after * it. */ switch (row_info->bit_depth) { case 1: { /* in this case, all bytes must be 0 so we don't need * to unpack the pixels except for the rightmost one. */ for (; rp > png_ptr->row_buf; rp--) { if ((*rp >> padding) != 0) png_ptr->num_palette_max = 1; padding = 0; } break; } case 2: { for (; rp > png_ptr->row_buf; rp--) { int i = ((*rp >> padding) & 0x03); if (i > png_ptr->num_palette_max) png_ptr->num_palette_max = i; i = (((*rp >> padding) >> 2) & 0x03); if (i > png_ptr->num_palette_max) png_ptr->num_palette_max = i; i = (((*rp >> padding) >> 4) & 0x03); if (i > png_ptr->num_palette_max) png_ptr->num_palette_max = i; i = (((*rp >> padding) >> 6) & 0x03); if (i > png_ptr->num_palette_max) png_ptr->num_palette_max = i; padding = 0; } break; } case 4: { for (; rp > png_ptr->row_buf; rp--) { int i = ((*rp >> padding) & 0x0f); if (i > png_ptr->num_palette_max) png_ptr->num_palette_max = i; i = (((*rp >> padding) >> 4) & 0x0f); if (i > png_ptr->num_palette_max) png_ptr->num_palette_max = i; padding = 0; } break; } case 8: { for (; rp > png_ptr->row_buf; rp--) { if (*rp > png_ptr->num_palette_max) png_ptr->num_palette_max = (int) *rp; } break; } default: break; } } } #endif /* CHECK_FOR_INVALID_INDEX */ #if defined(PNG_READ_TRANSFORMS_SUPPORTED) ||\ defined(PNG_WRITE_TRANSFORMS_SUPPORTED) /* Utility functions: */ void png_init_transform_control(png_const_structrp png_ptr, png_transform_controlp out, png_const_row_infop row_info) { out->png_ptr = png_ptr; /* At the start expect row_info to be consistent with png_ptr: */ if (png_ptr->mode & PNG_IS_READ_STRUCT) { debug(png_ptr->iwidth == row_info->width); debug(png_ptr->color_type == row_info->color_type); debug(png_ptr->bit_depth == row_info->bit_depth); } out->width = row_info->width; out->flags = 0; out->bit_depth = row_info->bit_depth; switch (row_info->color_type) { case PNG_COLOR_TYPE_GRAY: out->channels = 1; break; case PNG_COLOR_TYPE_GRAY_ALPHA: out->channels = 2; break; case PNG_COLOR_TYPE_PALETTE: affirm(!(png_ptr->mode & PNG_IS_READ_STRUCT) || png_ptr->palette != NULL); out->flags |= PNG_INDEXED; out->channels = 1; break; case PNG_COLOR_TYPE_RGB: out->channels = 3; break; case PNG_COLOR_TYPE_RGB_ALPHA: out->channels = 4; break; default: impossible("invalid PNG color type"); } } size_t png_transform_rowbytes(png_const_transform_controlp row_info) { # define png_ptr row_info->png_ptr /* For this not to overflow the pixel depth calculation must not overflow * and the pixel depth must be less than maximum_pixel_depth. */ /* The release code uses PNG_ROWBYTES, so make sure that it will not * overflow. To test this it is necessary to generate some very wide * images and ensure that the code errors out before getting here. */ unsigned int channels = row_info->channels; unsigned int bit_depth = row_info->bit_depth; unsigned int pixel_bits = channels * bit_depth; size_t width = row_info->width; affirm(bit_depth < 256 && channels < 256 && pixel_bits <= png_ptr->maximum_pixel_depth); return PNG_ROWBYTES(pixel_bits, width); # undef png_ptr } static unsigned int transform_color_type(png_const_transform_controlp row_info) { const unsigned int ch = row_info->channels - 1; const unsigned int indexed = row_info->flags & PNG_INDEXED; /* That is 0, 1, 2, 3 for G/PALETTE, GA, RGB, RGBA. Check the * numbers: */ # if PNG_INDEXED != PNG_COLOR_MASK_PALETTE ||\ PNG_FILLER_IN_ALPHA != PNG_COLOR_MASK_ALPHA ||\ PNG_COLOR_MASK_PALETTE != 1 ||\ PNG_COLOR_MASK_COLOR != 2 ||\ PNG_COLOR_MASK_ALPHA != 4 # error Unexpected PNG color type defines # endif /* The following preserves all the bits in row_info->channels except the * top bit and generates a correct PNG color type for the defined values * and an incorrect one for all undefined cases. * * Note that when PNG_FILLER_IN_ALPHA is set in the flags */ return indexed /*PALETTE*/ | ((ch & 2) ^ (indexed << 1) /*COLOR*/) | (((ch & 1) << 2/*ALPHA*/) & ~row_info->flags) | ((ch & ~3) << 1 /*INVALID*/); } void png_end_transform_control(png_row_infop out, png_const_transform_controlp in) { # define png_ptr in->png_ptr /* for affirm/impossible */ out->width = in->width; out->rowbytes = png_transform_rowbytes(in); out->color_type = png_check_byte(png_ptr, transform_color_type(in)); out->bit_depth = png_check_byte(png_ptr, in->bit_depth); out->channels = png_check_byte(png_ptr, in->channels); out->pixel_depth = png_check_byte(png_ptr, in->channels * in->bit_depth); # ifdef PNG_WARNINGS_SUPPORTED if ((in->flags & PNG_BAD_INDEX) != 0) png_warning(png_ptr, "palette image had bad index"); # endif /* At the end expect row_info to be consistent with png_ptr: */ if (!(png_ptr->mode & PNG_IS_READ_STRUCT)) { debug(png_ptr->color_type == out->color_type); debug(png_ptr->bit_depth == out->bit_depth); } # undef png_ptr } #endif /* READ_TRANSFORMS | WRITE_TRANSFORMS */ #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED void PNGAPI png_set_user_transform_info(png_structrp png_ptr, png_voidp user_transform_ptr, int user_transform_depth, int user_transform_channels) { png_debug(1, "in png_set_user_transform_info"); if (png_ptr == NULL) return; #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0) { png_app_error(png_ptr, "info change after png_start_read_image or png_read_update_info"); return; } #endif png_ptr->user_transform_ptr = user_transform_ptr; png_ptr->user_transform_depth = png_check_byte(png_ptr, user_transform_depth); png_ptr->user_transform_channels = png_check_byte(png_ptr, user_transform_channels); } #endif /* This function returns a pointer to the user_transform_ptr associated with * the user transform functions. The application should free any memory * associated with this pointer before png_write_destroy and png_read_destroy * are called. */ #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED png_voidp PNGAPI png_get_user_transform_ptr(png_const_structrp png_ptr) { if (png_ptr == NULL) return (NULL); return png_ptr->user_transform_ptr; } #endif #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED png_uint_32 PNGAPI png_get_current_row_number(png_const_structrp png_ptr) { /* See the comments in png.h - this is the sub-image row when reading an * interlaced image. */ if (png_ptr != NULL) return png_ptr->row_number; return PNG_UINT_32_MAX; /* help the app not to fail silently */ } png_byte PNGAPI png_get_current_pass_number(png_const_structrp png_ptr) { if (png_ptr != NULL) return png_ptr->pass; return 8; /* invalid */ } #endif /* USER_TRANSFORM_INFO */ #endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */ #endif /* READ || WRITE */