pngtrans.c
Go to the documentation of this file.
00001 
00002 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
00003  *
00004  * Last changed in libpng 1.2.30 [August 15, 2008]
00005  * For conditions of distribution and use, see copyright notice in png.h
00006  * Copyright (c) 1998-2008 Glenn Randers-Pehrson
00007  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
00008  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
00009  */
00010 
00011 #define PNG_INTERNAL
00012 #include "png.h"
00013 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
00014 
00015 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
00016 /* turn on BGR-to-RGB mapping */
00017 void PNGAPI
00018 png_set_bgr(png_structp png_ptr)
00019 {
00020    png_debug(1, "in png_set_bgr\n");
00021    if (png_ptr == NULL) return;
00022    png_ptr->transformations |= PNG_BGR;
00023 }
00024 #endif
00025 
00026 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
00027 /* turn on 16 bit byte swapping */
00028 void PNGAPI
00029 png_set_swap(png_structp png_ptr)
00030 {
00031    png_debug(1, "in png_set_swap\n");
00032    if (png_ptr == NULL) return;
00033    if (png_ptr->bit_depth == 16)
00034       png_ptr->transformations |= PNG_SWAP_BYTES;
00035 }
00036 #endif
00037 
00038 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
00039 /* turn on pixel packing */
00040 void PNGAPI
00041 png_set_packing(png_structp png_ptr)
00042 {
00043    png_debug(1, "in png_set_packing\n");
00044    if (png_ptr == NULL) return;
00045    if (png_ptr->bit_depth < 8)
00046    {
00047       png_ptr->transformations |= PNG_PACK;
00048       png_ptr->usr_bit_depth = 8;
00049    }
00050 }
00051 #endif
00052 
00053 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
00054 /* turn on packed pixel swapping */
00055 void PNGAPI
00056 png_set_packswap(png_structp png_ptr)
00057 {
00058    png_debug(1, "in png_set_packswap\n");
00059    if (png_ptr == NULL) return;
00060    if (png_ptr->bit_depth < 8)
00061       png_ptr->transformations |= PNG_PACKSWAP;
00062 }
00063 #endif
00064 
00065 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
00066 void PNGAPI
00067 png_set_shift(png_structp png_ptr, png_color_8p true_bits)
00068 {
00069    png_debug(1, "in png_set_shift\n");
00070    if (png_ptr == NULL) return;
00071    png_ptr->transformations |= PNG_SHIFT;
00072    png_ptr->shift = *true_bits;
00073 }
00074 #endif
00075 
00076 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
00077     defined(PNG_WRITE_INTERLACING_SUPPORTED)
00078 int PNGAPI
00079 png_set_interlace_handling(png_structp png_ptr)
00080 {
00081    png_debug(1, "in png_set_interlace handling\n");
00082    if (png_ptr && png_ptr->interlaced)
00083    {
00084       png_ptr->transformations |= PNG_INTERLACE;
00085       return (7);
00086    }
00087 
00088    return (1);
00089 }
00090 #endif
00091 
00092 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
00093 /* Add a filler byte on read, or remove a filler or alpha byte on write.
00094  * The filler type has changed in v0.95 to allow future 2-byte fillers
00095  * for 48-bit input data, as well as to avoid problems with some compilers
00096  * that don't like bytes as parameters.
00097  */
00098 void PNGAPI
00099 png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
00100 {
00101    png_debug(1, "in png_set_filler\n");
00102    if (png_ptr == NULL) return;
00103    png_ptr->transformations |= PNG_FILLER;
00104    png_ptr->filler = (png_byte)filler;
00105    if (filler_loc == PNG_FILLER_AFTER)
00106       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
00107    else
00108       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
00109 
00110    /* This should probably go in the "do_read_filler" routine.
00111     * I attempted to do that in libpng-1.0.1a but that caused problems
00112     * so I restored it in libpng-1.0.2a
00113    */
00114 
00115    if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
00116    {
00117       png_ptr->usr_channels = 4;
00118    }
00119 
00120    /* Also I added this in libpng-1.0.2a (what happens when we expand
00121     * a less-than-8-bit grayscale to GA? */
00122 
00123    if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)
00124    {
00125       png_ptr->usr_channels = 2;
00126    }
00127 }
00128 
00129 #if !defined(PNG_1_0_X)
00130 /* Added to libpng-1.2.7 */
00131 void PNGAPI
00132 png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
00133 {
00134    png_debug(1, "in png_set_add_alpha\n");
00135    if (png_ptr == NULL) return;
00136    png_set_filler(png_ptr, filler, filler_loc);
00137    png_ptr->transformations |= PNG_ADD_ALPHA;
00138 }
00139 #endif
00140 
00141 #endif
00142 
00143 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
00144     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
00145 void PNGAPI
00146 png_set_swap_alpha(png_structp png_ptr)
00147 {
00148    png_debug(1, "in png_set_swap_alpha\n");
00149    if (png_ptr == NULL) return;
00150    png_ptr->transformations |= PNG_SWAP_ALPHA;
00151 }
00152 #endif
00153 
00154 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
00155     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
00156 void PNGAPI
00157 png_set_invert_alpha(png_structp png_ptr)
00158 {
00159    png_debug(1, "in png_set_invert_alpha\n");
00160    if (png_ptr == NULL) return;
00161    png_ptr->transformations |= PNG_INVERT_ALPHA;
00162 }
00163 #endif
00164 
00165 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
00166 void PNGAPI
00167 png_set_invert_mono(png_structp png_ptr)
00168 {
00169    png_debug(1, "in png_set_invert_mono\n");
00170    if (png_ptr == NULL) return;
00171    png_ptr->transformations |= PNG_INVERT_MONO;
00172 }
00173 
00174 /* invert monochrome grayscale data */
00175 void /* PRIVATE */
00176 png_do_invert(png_row_infop row_info, png_bytep row)
00177 {
00178    png_debug(1, "in png_do_invert\n");
00179   /* This test removed from libpng version 1.0.13 and 1.2.0:
00180    *   if (row_info->bit_depth == 1 &&
00181    */
00182 #if defined(PNG_USELESS_TESTS_SUPPORTED)
00183    if (row == NULL || row_info == NULL)
00184      return;
00185 #endif
00186    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
00187    {
00188       png_bytep rp = row;
00189       png_uint_32 i;
00190       png_uint_32 istop = row_info->rowbytes;
00191 
00192       for (i = 0; i < istop; i++)
00193       {
00194          *rp = (png_byte)(~(*rp));
00195          rp++;
00196       }
00197    }
00198    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
00199       row_info->bit_depth == 8)
00200    {
00201       png_bytep rp = row;
00202       png_uint_32 i;
00203       png_uint_32 istop = row_info->rowbytes;
00204 
00205       for (i = 0; i < istop; i+=2)
00206       {
00207          *rp = (png_byte)(~(*rp));
00208          rp+=2;
00209       }
00210    }
00211    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
00212       row_info->bit_depth == 16)
00213    {
00214       png_bytep rp = row;
00215       png_uint_32 i;
00216       png_uint_32 istop = row_info->rowbytes;
00217 
00218       for (i = 0; i < istop; i+=4)
00219       {
00220          *rp = (png_byte)(~(*rp));
00221          *(rp+1) = (png_byte)(~(*(rp+1)));
00222          rp+=4;
00223       }
00224    }
00225 }
00226 #endif
00227 
00228 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
00229 /* swaps byte order on 16 bit depth images */
00230 void /* PRIVATE */
00231 png_do_swap(png_row_infop row_info, png_bytep row)
00232 {
00233    png_debug(1, "in png_do_swap\n");
00234    if (
00235 #if defined(PNG_USELESS_TESTS_SUPPORTED)
00236        row != NULL && row_info != NULL &&
00237 #endif
00238        row_info->bit_depth == 16)
00239    {
00240       png_bytep rp = row;
00241       png_uint_32 i;
00242       png_uint_32 istop= row_info->width * row_info->channels;
00243 
00244       for (i = 0; i < istop; i++, rp += 2)
00245       {
00246          png_byte t = *rp;
00247          *rp = *(rp + 1);
00248          *(rp + 1) = t;
00249       }
00250    }
00251 }
00252 #endif
00253 
00254 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
00255 static PNG_CONST png_byte onebppswaptable[256] = {
00256    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
00257    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
00258    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
00259    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
00260    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
00261    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
00262    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
00263    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
00264    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
00265    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
00266    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
00267    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
00268    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
00269    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
00270    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
00271    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
00272    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
00273    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
00274    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
00275    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
00276    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
00277    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
00278    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
00279    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
00280    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
00281    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
00282    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
00283    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
00284    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
00285    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
00286    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
00287    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
00288 };
00289 
00290 static PNG_CONST png_byte twobppswaptable[256] = {
00291    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
00292    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
00293    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
00294    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
00295    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
00296    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
00297    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
00298    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
00299    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
00300    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
00301    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
00302    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
00303    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
00304    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
00305    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
00306    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
00307    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
00308    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
00309    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
00310    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
00311    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
00312    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
00313    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
00314    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
00315    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
00316    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
00317    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
00318    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
00319    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
00320    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
00321    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
00322    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
00323 };
00324 
00325 static PNG_CONST png_byte fourbppswaptable[256] = {
00326    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
00327    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
00328    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
00329    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
00330    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
00331    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
00332    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
00333    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
00334    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
00335    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
00336    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
00337    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
00338    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
00339    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
00340    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
00341    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
00342    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
00343    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
00344    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
00345    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
00346    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
00347    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
00348    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
00349    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
00350    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
00351    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
00352    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
00353    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
00354    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
00355    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
00356    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
00357    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
00358 };
00359 
00360 /* swaps pixel packing order within bytes */
00361 void /* PRIVATE */
00362 png_do_packswap(png_row_infop row_info, png_bytep row)
00363 {
00364    png_debug(1, "in png_do_packswap\n");
00365    if (
00366 #if defined(PNG_USELESS_TESTS_SUPPORTED)
00367        row != NULL && row_info != NULL &&
00368 #endif
00369        row_info->bit_depth < 8)
00370    {
00371       png_bytep rp, end, table;
00372 
00373       end = row + row_info->rowbytes;
00374 
00375       if (row_info->bit_depth == 1)
00376          table = (png_bytep)onebppswaptable;
00377       else if (row_info->bit_depth == 2)
00378          table = (png_bytep)twobppswaptable;
00379       else if (row_info->bit_depth == 4)
00380          table = (png_bytep)fourbppswaptable;
00381       else
00382          return;
00383 
00384       for (rp = row; rp < end; rp++)
00385          *rp = table[*rp];
00386    }
00387 }
00388 #endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
00389 
00390 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
00391     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
00392 /* remove filler or alpha byte(s) */
00393 void /* PRIVATE */
00394 png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
00395 {
00396    png_debug(1, "in png_do_strip_filler\n");
00397 #if defined(PNG_USELESS_TESTS_SUPPORTED)
00398    if (row != NULL && row_info != NULL)
00399 #endif
00400    {
00401       png_bytep sp=row;
00402       png_bytep dp=row;
00403       png_uint_32 row_width=row_info->width;
00404       png_uint_32 i;
00405 
00406       if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
00407          (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
00408          (flags & PNG_FLAG_STRIP_ALPHA))) &&
00409          row_info->channels == 4)
00410       {
00411          if (row_info->bit_depth == 8)
00412          {
00413             /* This converts from RGBX or RGBA to RGB */
00414             if (flags & PNG_FLAG_FILLER_AFTER)
00415             {
00416                dp+=3; sp+=4;
00417                for (i = 1; i < row_width; i++)
00418                {
00419                   *dp++ = *sp++;
00420                   *dp++ = *sp++;
00421                   *dp++ = *sp++;
00422                   sp++;
00423                }
00424             }
00425             /* This converts from XRGB or ARGB to RGB */
00426             else
00427             {
00428                for (i = 0; i < row_width; i++)
00429                {
00430                   sp++;
00431                   *dp++ = *sp++;
00432                   *dp++ = *sp++;
00433                   *dp++ = *sp++;
00434                }
00435             }
00436             row_info->pixel_depth = 24;
00437             row_info->rowbytes = row_width * 3;
00438          }
00439          else /* if (row_info->bit_depth == 16) */
00440          {
00441             if (flags & PNG_FLAG_FILLER_AFTER)
00442             {
00443                /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
00444                sp += 8; dp += 6;
00445                for (i = 1; i < row_width; i++)
00446                {
00447                   /* This could be (although png_memcpy is probably slower):
00448                   png_memcpy(dp, sp, 6);
00449                   sp += 8;
00450                   dp += 6;
00451                   */
00452 
00453                   *dp++ = *sp++;
00454                   *dp++ = *sp++;
00455                   *dp++ = *sp++;
00456                   *dp++ = *sp++;
00457                   *dp++ = *sp++;
00458                   *dp++ = *sp++;
00459                   sp += 2;
00460                }
00461             }
00462             else
00463             {
00464                /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
00465                for (i = 0; i < row_width; i++)
00466                {
00467                   /* This could be (although png_memcpy is probably slower):
00468                   png_memcpy(dp, sp, 6);
00469                   sp += 8;
00470                   dp += 6;
00471                   */
00472 
00473                   sp+=2;
00474                   *dp++ = *sp++;
00475                   *dp++ = *sp++;
00476                   *dp++ = *sp++;
00477                   *dp++ = *sp++;
00478                   *dp++ = *sp++;
00479                   *dp++ = *sp++;
00480                }
00481             }
00482             row_info->pixel_depth = 48;
00483             row_info->rowbytes = row_width * 6;
00484          }
00485          row_info->channels = 3;
00486       }
00487       else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||
00488          (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
00489          (flags & PNG_FLAG_STRIP_ALPHA))) &&
00490           row_info->channels == 2)
00491       {
00492          if (row_info->bit_depth == 8)
00493          {
00494             /* This converts from GX or GA to G */
00495             if (flags & PNG_FLAG_FILLER_AFTER)
00496             {
00497                for (i = 0; i < row_width; i++)
00498                {
00499                   *dp++ = *sp++;
00500                   sp++;
00501                }
00502             }
00503             /* This converts from XG or AG to G */
00504             else
00505             {
00506                for (i = 0; i < row_width; i++)
00507                {
00508                   sp++;
00509                   *dp++ = *sp++;
00510                }
00511             }
00512             row_info->pixel_depth = 8;
00513             row_info->rowbytes = row_width;
00514          }
00515          else /* if (row_info->bit_depth == 16) */
00516          {
00517             if (flags & PNG_FLAG_FILLER_AFTER)
00518             {
00519                /* This converts from GGXX or GGAA to GG */
00520                sp += 4; dp += 2;
00521                for (i = 1; i < row_width; i++)
00522                {
00523                   *dp++ = *sp++;
00524                   *dp++ = *sp++;
00525                   sp += 2;
00526                }
00527             }
00528             else
00529             {
00530                /* This converts from XXGG or AAGG to GG */
00531                for (i = 0; i < row_width; i++)
00532                {
00533                   sp += 2;
00534                   *dp++ = *sp++;
00535                   *dp++ = *sp++;
00536                }
00537             }
00538             row_info->pixel_depth = 16;
00539             row_info->rowbytes = row_width * 2;
00540          }
00541          row_info->channels = 1;
00542       }
00543       if (flags & PNG_FLAG_STRIP_ALPHA)
00544         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;
00545    }
00546 }
00547 #endif
00548 
00549 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
00550 /* swaps red and blue bytes within a pixel */
00551 void /* PRIVATE */
00552 png_do_bgr(png_row_infop row_info, png_bytep row)
00553 {
00554    png_debug(1, "in png_do_bgr\n");
00555    if (
00556 #if defined(PNG_USELESS_TESTS_SUPPORTED)
00557        row != NULL && row_info != NULL &&
00558 #endif
00559        (row_info->color_type & PNG_COLOR_MASK_COLOR))
00560    {
00561       png_uint_32 row_width = row_info->width;
00562       if (row_info->bit_depth == 8)
00563       {
00564          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
00565          {
00566             png_bytep rp;
00567             png_uint_32 i;
00568 
00569             for (i = 0, rp = row; i < row_width; i++, rp += 3)
00570             {
00571                png_byte save = *rp;
00572                *rp = *(rp + 2);
00573                *(rp + 2) = save;
00574             }
00575          }
00576          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
00577          {
00578             png_bytep rp;
00579             png_uint_32 i;
00580 
00581             for (i = 0, rp = row; i < row_width; i++, rp += 4)
00582             {
00583                png_byte save = *rp;
00584                *rp = *(rp + 2);
00585                *(rp + 2) = save;
00586             }
00587          }
00588       }
00589       else if (row_info->bit_depth == 16)
00590       {
00591          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
00592          {
00593             png_bytep rp;
00594             png_uint_32 i;
00595 
00596             for (i = 0, rp = row; i < row_width; i++, rp += 6)
00597             {
00598                png_byte save = *rp;
00599                *rp = *(rp + 4);
00600                *(rp + 4) = save;
00601                save = *(rp + 1);
00602                *(rp + 1) = *(rp + 5);
00603                *(rp + 5) = save;
00604             }
00605          }
00606          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
00607          {
00608             png_bytep rp;
00609             png_uint_32 i;
00610 
00611             for (i = 0, rp = row; i < row_width; i++, rp += 8)
00612             {
00613                png_byte save = *rp;
00614                *rp = *(rp + 4);
00615                *(rp + 4) = save;
00616                save = *(rp + 1);
00617                *(rp + 1) = *(rp + 5);
00618                *(rp + 5) = save;
00619             }
00620          }
00621       }
00622    }
00623 }
00624 #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
00625 
00626 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
00627     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
00628     defined(PNG_LEGACY_SUPPORTED)
00629 void PNGAPI
00630 png_set_user_transform_info(png_structp png_ptr, png_voidp
00631    user_transform_ptr, int user_transform_depth, int user_transform_channels)
00632 {
00633    png_debug(1, "in png_set_user_transform_info\n");
00634    if (png_ptr == NULL) return;
00635 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
00636    png_ptr->user_transform_ptr = user_transform_ptr;
00637    png_ptr->user_transform_depth = (png_byte)user_transform_depth;
00638    png_ptr->user_transform_channels = (png_byte)user_transform_channels;
00639 #else
00640    if (user_transform_ptr || user_transform_depth || user_transform_channels)
00641       png_warning(png_ptr,
00642         "This version of libpng does not support user transform info");
00643 #endif
00644 }
00645 #endif
00646 
00647 /* This function returns a pointer to the user_transform_ptr associated with
00648  * the user transform functions.  The application should free any memory
00649  * associated with this pointer before png_write_destroy and png_read_destroy
00650  * are called.
00651  */
00652 png_voidp PNGAPI
00653 png_get_user_transform_ptr(png_structp png_ptr)
00654 {
00655    if (png_ptr == NULL) return (NULL);
00656 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
00657    return ((png_voidp)png_ptr->user_transform_ptr);
00658 #else
00659    return (NULL);
00660 #endif
00661 }
00662 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sun Apr 2 2017 03:43:56