#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Classes
struct	LodeZlib_DeflateSettings

struct	LodePNG_InfoColor

struct	LodePNG_InfoPng

struct	LodePNG_InfoRaw

struct	LodePNG_EncodeSettings

struct	LodePNG_Encoder

Macros
#define	LODEPNG_COMPILE_ZLIB /deflate&zlib encoder and deflate&zlib decoder/

#define	LODEPNG_COMPILE_PNG /png encoder and png decoder/

#define	LODEPNG_COMPILE_ENCODER /deflate&zlib encoder and png encoder/

#define	LODEPNG_COMPILE_DISK /the optional built in harddisk file loading and saving functions/

Typedefs
typedef struct LodeZlib_DeflateSettings	LodeZlib_DeflateSettings

typedef struct LodePNG_InfoColor	LodePNG_InfoColor

typedef struct LodePNG_InfoPng	LodePNG_InfoPng

typedef struct LodePNG_InfoRaw	LodePNG_InfoRaw

typedef struct LodePNG_EncodeSettings	LodePNG_EncodeSettings

typedef struct LodePNG_Encoder	LodePNG_Encoder

Functions
void	LodeZlib_DeflateSettings_init (LodeZlib_DeflateSettings *settings)

unsigned	LodeZlib_compress (unsigned char *out, size_t outsize, const unsigned char in, size_t insize, const LodeZlib_DeflateSettings settings)

unsigned	LodePNG_chunk_length (const unsigned char *chunk)

void	LodePNG_chunk_type (char type[5], const unsigned char *chunk)

unsigned char	LodePNG_chunk_type_equals (const unsigned char chunk, const char type)

unsigned char	LodePNG_chunk_critical (const unsigned char *chunk)

unsigned char	LodePNG_chunk_private (const unsigned char *chunk)

unsigned char	LodePNG_chunk_safetocopy (const unsigned char *chunk)

unsigned char *	LodePNG_chunk_data (unsigned char *chunk)

const unsigned char *	LodePNG_chunk_data_const (const unsigned char *chunk)

unsigned	LodePNG_chunk_check_crc (const unsigned char *chunk)

void	LodePNG_chunk_generate_crc (unsigned char *chunk)

unsigned char *	LodePNG_chunk_next (unsigned char *chunk)

const unsigned char *	LodePNG_chunk_next_const (const unsigned char *chunk)

unsigned	LodePNG_append_chunk (unsigned char *out, size_t outlength, const unsigned char *chunk)

unsigned	LodePNG_create_chunk (unsigned char *out, size_t outlength, unsigned length, const char type, const unsigned char data)

void	LodePNG_InfoColor_init (LodePNG_InfoColor *info)

void	LodePNG_InfoColor_cleanup (LodePNG_InfoColor *info)

unsigned	LodePNG_InfoColor_copy (LodePNG_InfoColor dest, const LodePNG_InfoColor source)

void	LodePNG_InfoColor_clearPalette (LodePNG_InfoColor *info)

unsigned	LodePNG_InfoColor_addPalette (LodePNG_InfoColor *info, unsigned char r, unsigned char g, unsigned char b, unsigned char a)

unsigned	LodePNG_InfoColor_getBpp (const LodePNG_InfoColor *info)

unsigned	LodePNG_InfoColor_getChannels (const LodePNG_InfoColor *info)

unsigned	LodePNG_InfoColor_isGreyscaleType (const LodePNG_InfoColor *info)

unsigned	LodePNG_InfoColor_isAlphaType (const LodePNG_InfoColor *info)

void	LodePNG_InfoPng_init (LodePNG_InfoPng *info)

void	LodePNG_InfoPng_cleanup (LodePNG_InfoPng *info)

unsigned	LodePNG_InfoPng_copy (LodePNG_InfoPng dest, const LodePNG_InfoPng source)

void	LodePNG_InfoRaw_init (LodePNG_InfoRaw *info)

void	LodePNG_InfoRaw_cleanup (LodePNG_InfoRaw *info)

unsigned	LodePNG_InfoRaw_copy (LodePNG_InfoRaw dest, const LodePNG_InfoRaw source)

unsigned	LodePNG_convert (unsigned char out, const unsigned char in, LodePNG_InfoColor infoOut, LodePNG_InfoColor infoIn, unsigned w, unsigned h)

void	LodePNG_EncodeSettings_init (LodePNG_EncodeSettings *settings)

void	LodePNG_Encoder_init (LodePNG_Encoder *encoder)

void	LodePNG_Encoder_cleanup (LodePNG_Encoder *encoder)

void	LodePNG_Encoder_copy (LodePNG_Encoder dest, const LodePNG_Encoder source)

void	LodePNG_encode (LodePNG_Encoder encoder, unsigned char out, size_t outsize, const unsigned char *image, unsigned w, unsigned h)

unsigned	LodePNG_encode32 (unsigned char *out, size_t outsize, const unsigned char *image, unsigned w, unsigned h)

unsigned	LodePNG_encode32f (const char filename, const unsigned char image, unsigned w, unsigned h)

unsigned	LodePNG_loadFile (unsigned char *out, size_t outsize, const char *filename)

unsigned	LodePNG_saveFile (const unsigned char buffer, size_t buffersize, const char filename)

Variables
const LodeZlib_DeflateSettings	LodeZlib_defaultDeflateSettings

Macro Definition Documentation

#define LODEPNG_COMPILE_DISK /*the optional built in harddisk file loading and saving functions*/

Definition at line 43 of file lodepng.h.

#define LODEPNG_COMPILE_ENCODER /*deflate&zlib encoder and png encoder*/

Definition at line 42 of file lodepng.h.

#define LODEPNG_COMPILE_PNG /*png encoder and png decoder*/

Definition at line 40 of file lodepng.h.

#define LODEPNG_COMPILE_ZLIB /*deflate&zlib encoder and deflate&zlib decoder*/

Definition at line 39 of file lodepng.h.

Typedef Documentation

typedef struct LodePNG_Encoder LodePNG_Encoder

typedef struct LodePNG_EncodeSettings LodePNG_EncodeSettings

typedef struct LodePNG_InfoColor LodePNG_InfoColor

typedef struct LodePNG_InfoPng LodePNG_InfoPng

typedef struct LodePNG_InfoRaw LodePNG_InfoRaw

typedef struct LodeZlib_DeflateSettings LodeZlib_DeflateSettings

Function Documentation

unsigned LodePNG_append_chunk	(	unsigned char **	out,
		size_t *	outlength,
		const unsigned char *	chunk
	)

Definition at line 1937 of file lodepng.cpp.

 {
   unsigned i;
   unsigned total_chunk_length = LodePNG_chunk_length(chunk) + 12;
   unsigned char *chunk_start, *new_buffer;
   size_t new_length = (*outlength) + total_chunk_length;
   if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/
   
   new_buffer = (unsigned char*)realloc(*out, new_length);
   if(!new_buffer) return 9929;
   (*out) = new_buffer;
   (*outlength) = new_length;
   chunk_start = &(*out)[new_length - total_chunk_length];
   
   for(i = 0; i < total_chunk_length; i++) chunk_start[i] = chunk[i];
   
   return 0;
 }

unsigned LodePNG_chunk_check_crc ( const unsigned char * chunk )

Definition at line 1909 of file lodepng.cpp.

 {
   unsigned length = LodePNG_chunk_length(chunk);
   unsigned CRC = LodePNG_read32bitInt(&chunk[length + 8]);
   unsigned checksum = Crc32_crc(&chunk[4], length + 4); /*the CRC is taken of the data and the 4 chunk type letters, not the length*/
   if(CRC != checksum) return 1;
   else return 0;
 }

unsigned char LodePNG_chunk_critical ( const unsigned char * chunk )

Definition at line 1884 of file lodepng.cpp.

 {
   return((chunk[4] & 32) == 0);
 }

unsigned char* LodePNG_chunk_data ( unsigned char * chunk )

Definition at line 1899 of file lodepng.cpp.

 {
   return &chunk[8];
 }

const unsigned char* LodePNG_chunk_data_const ( const unsigned char * chunk )

Definition at line 1904 of file lodepng.cpp.

 {
   return &chunk[8];
 }

void LodePNG_chunk_generate_crc ( unsigned char * chunk )

Definition at line 1918 of file lodepng.cpp.

 {
   unsigned length = LodePNG_chunk_length(chunk);
   unsigned CRC = Crc32_crc(&chunk[4], length + 4);
   LodePNG_set32bitInt(chunk + 8 + length, CRC);
 }

unsigned LodePNG_chunk_length ( const unsigned char * chunk )

Definition at line 1865 of file lodepng.cpp.

 {
   return LodePNG_read32bitInt(&chunk[0]);
 }

unsigned char* LodePNG_chunk_next ( unsigned char * chunk )

Definition at line 1925 of file lodepng.cpp.

 {
   unsigned total_chunk_length = LodePNG_chunk_length(chunk) + 12;
   return &chunk[total_chunk_length];
 }

const unsigned char* LodePNG_chunk_next_const ( const unsigned char * chunk )

Definition at line 1931 of file lodepng.cpp.

 {
   unsigned total_chunk_length = LodePNG_chunk_length(chunk) + 12;
   return &chunk[total_chunk_length];
 }

unsigned char LodePNG_chunk_private ( const unsigned char * chunk )

Definition at line 1889 of file lodepng.cpp.

 {
   return((chunk[6] & 32) != 0);
 }

unsigned char LodePNG_chunk_safetocopy ( const unsigned char * chunk )

Definition at line 1894 of file lodepng.cpp.

 {
   return((chunk[7] & 32) != 0);
 }

void LodePNG_chunk_type	(	char	type[5],
		const unsigned char *	chunk
	)

Definition at line 1870 of file lodepng.cpp.

 {
   unsigned i;
   for(i = 0; i < 4; i++) type[i] = chunk[4 + i];
   type[4] = 0; /*null termination char*/
 }

unsigned char LodePNG_chunk_type_equals	(	const unsigned char *	chunk,
		const char *	type
	)

Definition at line 1877 of file lodepng.cpp.

 {
   if(strlen(type) != 4) return 0;
   return (chunk[4] == type[0] && chunk[5] == type[1] && chunk[6] == type[2] && chunk[7] == type[3]);
 }

unsigned LodePNG_convert	(	unsigned char *	out,
		const unsigned char *	in,
		LodePNG_InfoColor *	infoOut,
		LodePNG_InfoColor *	infoIn,
		unsigned	w,
		unsigned	h
	)

Definition at line 2361 of file lodepng.cpp.

 {
   const size_t numpixels = w * h; /*amount of pixels*/
   const unsigned OUT_BYTES = LodePNG_InfoColor_getBpp(infoOut) / 8; /*bytes per pixel in the output image*/
   const unsigned OUT_ALPHA = LodePNG_InfoColor_isAlphaType(infoOut); /*use 8-bit alpha channel*/
   size_t i, c, bp = 0; /*bitpointer, used by less-than-8-bit color types*/
   
   /*cases where in and out already have the same format*/
   if(LodePNG_InfoColor_equal(infoIn, infoOut))
   {
     size_t i, size = (w * h * LodePNG_InfoColor_getBpp(infoIn) + 7) / 8;
     for(i = 0; i < size; i++) out[i] = in[i];
     return 0;
   }
 
   if((infoOut->colorType == 2 || infoOut->colorType == 6) && infoOut->bitDepth == 8)
   {
     if(infoIn->bitDepth == 8)
     {
       switch(infoIn->colorType)
       {
         case 0: /*greyscale color*/
           for(i = 0; i < numpixels; i++)
           {
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = 255;
             out[OUT_BYTES * i + 0] = out[OUT_BYTES * i + 1] = out[OUT_BYTES * i + 2] = in[i];
             if(OUT_ALPHA && infoIn->key_defined && in[i] == infoIn->key_r) out[OUT_BYTES * i + 3] = 0;
           }
         break;
         case 2: /*RGB color*/
           for(i = 0; i < numpixels; i++)
           {
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = 255;
             for(c = 0; c < 3; c++) out[OUT_BYTES * i + c] = in[3 * i + c];
             if(OUT_ALPHA && infoIn->key_defined == 1 && in[3 * i + 0] == infoIn->key_r && in[3 * i + 1] == infoIn->key_g && in[3 * i + 2] == infoIn->key_b) out[OUT_BYTES * i + 3] = 0;
           }
         break;
         case 3: /*indexed color (palette)*/
           for(i = 0; i < numpixels; i++)
           {
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = 255;
             if(in[i] >= infoIn->palettesize) return 46;
             for(c = 0; c < OUT_BYTES; c++) out[OUT_BYTES * i + c] = infoIn->palette[4 * in[i] + c]; /*get rgb colors from the palette*/
           }
         break;
         case 4: /*greyscale with alpha*/
           for(i = 0; i < numpixels; i++)
           {
             out[OUT_BYTES * i + 0] = out[OUT_BYTES * i + 1] = out[OUT_BYTES * i + 2] = in[2 * i + 0];
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = in[2 * i + 1];
           }
         break;
         case 6: /*RGB with alpha*/
           for(i = 0; i < numpixels; i++)
           {
             for(c = 0; c < OUT_BYTES; c++) out[OUT_BYTES * i + c] = in[4 * i + c];
           }
         break;
         default: break;
       }
     }
     else if(infoIn->bitDepth == 16)
     {
       switch(infoIn->colorType)
       {
         case 0: /*greyscale color*/
           for(i = 0; i < numpixels; i++)
           {
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = 255;
             out[OUT_BYTES * i + 0] = out[OUT_BYTES * i + 1] = out[OUT_BYTES * i + 2] = in[2 * i];
             if(OUT_ALPHA && infoIn->key_defined && 256U * in[i] + in[i + 1] == infoIn->key_r) out[OUT_BYTES * i + 3] = 0;
           }
         break;
         case 2: /*RGB color*/
           for(i = 0; i < numpixels; i++)
           {
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = 255;
             for(c = 0; c < 3; c++) out[OUT_BYTES * i + c] = in[6 * i + 2 * c];
             if(OUT_ALPHA && infoIn->key_defined && 256U * in[6 * i + 0] + in[6 * i + 1] == infoIn->key_r && 256U * in[6 * i + 2] + in[6 * i + 3] == infoIn->key_g && 256U * in[6 * i + 4] + in[6 * i + 5] == infoIn->key_b) out[OUT_BYTES * i + 3] = 0;
           }
         break;
         case 4: /*greyscale with alpha*/
           for(i = 0; i < numpixels; i++)
           {
             out[OUT_BYTES * i + 0] = out[OUT_BYTES * i + 1] = out[OUT_BYTES * i + 2] = in[4 * i]; /*most significant byte*/
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = in[4 * i + 2];
           }
         break;
         case 6: /*RGB with alpha*/
           for(i = 0; i < numpixels; i++)
           {
             for(c = 0; c < OUT_BYTES; c++) out[OUT_BYTES * i + c] = in[8 * i + 2 * c];
           }
           break;
         default: break;
       }
     }
     else /*infoIn->bitDepth is less than 8 bit per channel*/
     {
       switch(infoIn->colorType)
       {
         case 0: /*greyscale color*/
           for(i = 0; i < numpixels; i++)
           {
             unsigned value = readBitsFromReversedStream(&bp, in, infoIn->bitDepth);
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = 255;
             if(OUT_ALPHA && infoIn->key_defined && value && ((1U << infoIn->bitDepth) - 1U) == infoIn->key_r && ((1U << infoIn->bitDepth) - 1U)) out[OUT_BYTES * i + 3] = 0;
             value = (value * 255) / ((1 << infoIn->bitDepth) - 1); /*scale value from 0 to 255*/
             out[OUT_BYTES * i + 0] = out[OUT_BYTES * i + 1] = out[OUT_BYTES * i + 2] = (unsigned char)(value);
           }
         break;
         case 3: /*indexed color (palette)*/
           for(i = 0; i < numpixels; i++)
           {
             unsigned value = readBitsFromReversedStream(&bp, in, infoIn->bitDepth);
             if(OUT_ALPHA) out[OUT_BYTES * i + 3] = 255;
             if(value >= infoIn->palettesize) return 47;
             for(c = 0; c < OUT_BYTES; c++) out[OUT_BYTES * i + c] = infoIn->palette[4 * value + c]; /*get rgb colors from the palette*/
           }
         break;
         default: break;
       }
     }
   }
   else if(LodePNG_InfoColor_isGreyscaleType(infoOut) && infoOut->bitDepth == 8) /*conversion from greyscale to greyscale*/
   {
     if(!LodePNG_InfoColor_isGreyscaleType(infoIn)) return 62;
     if(infoIn->bitDepth == 8)
     {
       switch(infoIn->colorType)
       {
         case 0: /*greyscale color*/
           for(i = 0; i < numpixels; i++)
           {
             if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
             out[OUT_BYTES * i] = in[i];
             if(OUT_ALPHA && infoIn->key_defined && in[i] == infoIn->key_r) out[OUT_BYTES * i + 1] = 0;
           }
         break;
         case 4: /*greyscale with alpha*/
           for(i = 0; i < numpixels; i++)
           {
             out[OUT_BYTES * i + 0] = in[2 * i + 0];
             if(OUT_ALPHA) out[OUT_BYTES * i + 1] = in[2 * i + 1];
           }
         break;
         default: return 31;
       }
     }
     else if(infoIn->bitDepth == 16)
     {
       switch(infoIn->colorType)
       {
         case 0: /*greyscale color*/
           for(i = 0; i < numpixels; i++)
           {
             if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
             out[OUT_BYTES * i] = in[2 * i];
             if(OUT_ALPHA && infoIn->key_defined && 256U * in[i] + in[i + 1] == infoIn->key_r) out[OUT_BYTES * i + 1] = 0;
           }
         break;
         case 4: /*greyscale with alpha*/
           for(i = 0; i < numpixels; i++)
           {
             out[OUT_BYTES * i] = in[4 * i]; /*most significant byte*/
             if(OUT_ALPHA) out[OUT_BYTES * i + 1] = in[4 * i + 2]; /*most significant byte*/
           }
         break;
         default: return 31;
       }
     }
     else /*infoIn->bitDepth is less than 8 bit per channel*/
     {
       if(infoIn->colorType != 0) return 31; /*colorType 0 is the only greyscale type with < 8 bits per channel*/
       for(i = 0; i < numpixels; i++)
       {
         unsigned value = readBitsFromReversedStream(&bp, in, infoIn->bitDepth);
         if(OUT_ALPHA) out[OUT_BYTES * i + 1] = 255;
         if(OUT_ALPHA && infoIn->key_defined && value && ((1U << infoIn->bitDepth) - 1U) == infoIn->key_r && ((1U << infoIn->bitDepth) - 1U)) out[OUT_BYTES * i + 1] = 0;
         value = (value * 255) / ((1 << infoIn->bitDepth) - 1); /*scale value from 0 to 255*/
         out[OUT_BYTES * i] = (unsigned char)(value);
       }
     }
   }
   else return 59;
   
   return 0;
 }

unsigned LodePNG_create_chunk	(	unsigned char **	out,
		size_t *	outlength,
		unsigned	length,
		const char *	type,
		const unsigned char *	data
	)

Definition at line 1956 of file lodepng.cpp.

 {
   unsigned i;
   unsigned char *chunk, *new_buffer;
   size_t new_length = (*outlength) + length + 12;
   if(new_length < length + 12 || new_length < (*outlength)) return 77; /*integer overflow happened*/
   new_buffer = (unsigned char*)realloc(*out, new_length);
   if(!new_buffer) return 9930;
   (*out) = new_buffer;
   (*outlength) = new_length;
   chunk = &(*out)[(*outlength) - length - 12];
   
   /*1: length*/
   LodePNG_set32bitInt(chunk, (unsigned)length);
   
   /*2: chunk name (4 letters)*/
   chunk[4] = type[0];
   chunk[5] = type[1];
   chunk[6] = type[2];
   chunk[7] = type[3];
   
   /*3: the data*/
   for(i = 0; i < length; i++) chunk[8 + i] = data[i];
   
   /*4: CRC (of the chunkname characters and the data)*/
   LodePNG_chunk_generate_crc(chunk);
   
   return 0;
 }

void LodePNG_encode	(	LodePNG_Encoder *	encoder,
		unsigned char **	out,
		size_t *	outsize,
		const unsigned char *	image,
		unsigned	w,
		unsigned	h
	)

Definition at line 3910 of file lodepng.cpp.

 {
   LodePNG_InfoPng info;
   ucvector outv;
   unsigned char* data = 0; /*uncompressed version of the IDAT chunk data*/
   size_t datasize = 0;
   
   /*provide some proper output values if error will happen*/
   *out = 0;
   *outsize = 0;
   encoder->error = 0;
   
   info = encoder->infoPng; /*UNSAFE copy to avoid having to cleanup! but we will only change primitive parameters, and not invoke the cleanup function nor touch the palette's buffer so we use it safely*/
   info.width = w;
   info.height = h;
   
   if(encoder->settings.autoLeaveOutAlphaChannel && isFullyOpaque(image, w, h, &encoder->infoRaw.color))
   {
     /*go to a color type without alpha channel*/
     if(info.color.colorType == 6) info.color.colorType = 2;
     else if(info.color.colorType == 4) info.color.colorType = 0;
   }
   
   if(encoder->settings.zlibsettings.windowSize > 32768) { encoder->error = 60; return; } /*error: windowsize larger than allowed*/
   if(encoder->settings.zlibsettings.btype > 2) { encoder->error = 61; return; } /*error: unexisting btype*/
   if(encoder->infoPng.interlaceMethod > 1) { encoder->error = 71; return; } /*error: unexisting interlace mode*/
   if((encoder->error = checkColorValidity(info.color.colorType, info.color.bitDepth))) return; /*error: unexisting color type given*/
   if((encoder->error = checkColorValidity(encoder->infoRaw.color.colorType, encoder->infoRaw.color.bitDepth))) return; /*error: unexisting color type given*/
   
   if(!LodePNG_InfoColor_equal(&encoder->infoRaw.color, &info.color))
   {
     unsigned char* converted;
     size_t size = (w * h * LodePNG_InfoColor_getBpp(&info.color) + 7) / 8;
     
     if((info.color.colorType != 6 && info.color.colorType != 2) || (info.color.bitDepth != 8)) { encoder->error = 59; return; } /*for the output image, only these types are supported*/
     converted = (unsigned char*)malloc(size);
     if(!converted && size) encoder->error = 9955; /*error: malloc failed*/
     if(!encoder->error) encoder->error = LodePNG_convert(converted, image, &info.color, &encoder->infoRaw.color, w, h);
     if(!encoder->error) preProcessScanlines(&data, &datasize, converted, &info);/*filter(data.data, converted.data, w, h, LodePNG_InfoColor_getBpp(&info.color));*/
     free(converted);
   }
   else preProcessScanlines(&data, &datasize, image, &info);/*filter(data.data, image, w, h, LodePNG_InfoColor_getBpp(&info.color));*/
   
   ucvector_init(&outv);
   while(!encoder->error) /*not really a while loop, this is only used to break out if an error happens to avoid goto's to do the ucvector cleanup*/
   {
 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
     size_t i;
 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
     /*write signature and chunks*/
     writeSignature(&outv);
     /*IHDR*/
     addChunk_IHDR(&outv, w, h, info.color.bitDepth, info.color.colorType, info.interlaceMethod);
 #ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
     /*unknown chunks between IHDR and PLTE*/
     if(info.unknown_chunks.data[0]) { encoder->error = addUnknownChunks(&outv, info.unknown_chunks.data[0], info.unknown_chunks.datasize[0]); if(encoder->error) break; }
 #endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
     /*PLTE*/
     if(info.color.colorType == 3)
     {
       if(info.color.palettesize == 0 || info.color.palettesize > 256) { encoder->error = 68; break; }
       addChunk_PLTE(&outv, &info.color);
     }
     if(encoder->settings.force_palette && (info.color.colorType == 2 || info.color.colorType == 6))
     {
       if(info.color.palettesize == 0 || info.color.palettesize > 256) { encoder->error = 68; break; }
       addChunk_PLTE(&outv, &info.color);
     }
     /*tRNS*/
     if(info.color.colorType == 3 && !isPaletteFullyOpaque(info.color.palette, info.color.palettesize)) addChunk_tRNS(&outv, &info.color);
     if((info.color.colorType == 0 || info.color.colorType == 2) && info.color.key_defined) addChunk_tRNS(&outv, &info.color);
 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
     /*bKGD (must come between PLTE and the IDAt chunks*/
     if(info.background_defined) addChunk_bKGD(&outv, &info);
     /*pHYs (must come before the IDAT chunks)*/
     if(info.phys_defined) addChunk_pHYs(&outv, &info);
 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
 #ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
     /*unknown chunks between PLTE and IDAT*/
     if(info.unknown_chunks.data[1]) { encoder->error = addUnknownChunks(&outv, info.unknown_chunks.data[1], info.unknown_chunks.datasize[1]); if(encoder->error) break; }
 #endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
     /*IDAT (multiple IDAT chunks must be consecutive)*/
     encoder->error = addChunk_IDAT(&outv, data, datasize, &encoder->settings.zlibsettings);
     if(encoder->error) break;
 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
     /*tIME*/
     if(info.time_defined) addChunk_tIME(&outv, &info.time);
     /*tEXt and/or zTXt*/
     for(i = 0; i < info.text.num; i++)
     {
       if(strlen(info.text.keys[i]) > 79) { encoder->error = 66; break; }
       if(strlen(info.text.keys[i]) < 1) { encoder->error = 67; break; }
       if(encoder->settings.text_compression)
         addChunk_zTXt(&outv, info.text.keys[i], info.text.strings[i], &encoder->settings.zlibsettings);
       else
         addChunk_tEXt(&outv, info.text.keys[i], info.text.strings[i]);
     }
     /*LodePNG version id in text chunk*/
     if(encoder->settings.add_id)
     {
       unsigned alread_added_id_text = 0;
       for(i = 0; i < info.text.num; i++)
         if(!strcmp(info.text.keys[i], "LodePNG")) { alread_added_id_text = 1; break; }
       if(alread_added_id_text == 0)
         addChunk_tEXt(&outv, "LodePNG", VERSION_STRING); /*it's shorter as tEXt than as zTXt chunk*/
     }
     /*iTXt*/
     for(i = 0; i < info.itext.num; i++)
     {
       if(strlen(info.itext.keys[i]) > 79) { encoder->error = 66; break; }
       if(strlen(info.itext.keys[i]) < 1) { encoder->error = 67; break; }
       addChunk_iTXt(&outv, encoder->settings.text_compression,
                     info.itext.keys[i], info.itext.langtags[i], info.itext.transkeys[i], info.itext.strings[i], 
                     &encoder->settings.zlibsettings);
     }
 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
 #ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
     /*unknown chunks between IDAT and IEND*/
     if(info.unknown_chunks.data[2]) { encoder->error = addUnknownChunks(&outv, info.unknown_chunks.data[2], info.unknown_chunks.datasize[2]); if(encoder->error) break; }
 #endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
     /*IEND*/
     addChunk_IEND(&outv);
     
     break; /*this isn't really a while loop; no error happened so break out now!*/
   }
   
   free(data);
   /*instead of cleaning the vector up, give it to the output*/
   *out = outv.data;
   *outsize = outv.size;
 }

unsigned LodePNG_encode32	(	unsigned char **	out,
		size_t *	outsize,
		const unsigned char *	image,
		unsigned	w,
		unsigned	h
	)

Definition at line 4042 of file lodepng.cpp.

 {
   unsigned error;
   LodePNG_Encoder encoder;
   LodePNG_Encoder_init(&encoder);
   LodePNG_encode(&encoder, out, outsize, image, w, h);
   error = encoder.error;
   LodePNG_Encoder_cleanup(&encoder);
   return error;
 }

unsigned LodePNG_encode32f	(	const char *	filename,
		const unsigned char *	image,
		unsigned	w,
		unsigned	h
	)

Definition at line 4054 of file lodepng.cpp.

 {
   unsigned char* buffer;
   size_t buffersize;
   unsigned error = LodePNG_encode32(&buffer, &buffersize, image, w, h);
   LodePNG_saveFile(buffer, buffersize, filename);
   free(buffer);
   return error;
 }

void LodePNG_Encoder_cleanup ( LodePNG_Encoder * encoder )

Definition at line 4084 of file lodepng.cpp.

 {
   LodePNG_InfoPng_cleanup(&encoder->infoPng);
   LodePNG_InfoRaw_cleanup(&encoder->infoRaw);
 }

void LodePNG_Encoder_copy	(	LodePNG_Encoder *	dest,
		const LodePNG_Encoder *	source
	)

Definition at line 4090 of file lodepng.cpp.

 {
   LodePNG_Encoder_cleanup(dest);
   *dest = *source;
   LodePNG_InfoPng_init(&dest->infoPng);
   LodePNG_InfoRaw_init(&dest->infoRaw);
   dest->error = LodePNG_InfoPng_copy(&dest->infoPng, &source->infoPng); if(dest->error) return;
   dest->error = LodePNG_InfoRaw_copy(&dest->infoRaw, &source->infoRaw); if(dest->error) return;
 }

void LodePNG_Encoder_init ( LodePNG_Encoder * encoder )

Definition at line 4076 of file lodepng.cpp.

 {
   LodePNG_EncodeSettings_init(&encoder->settings);
   LodePNG_InfoPng_init(&encoder->infoPng);
   LodePNG_InfoRaw_init(&encoder->infoRaw);
   encoder->error = 1;
 }

void LodePNG_EncodeSettings_init ( LodePNG_EncodeSettings * settings )

Definition at line 4065 of file lodepng.cpp.

 {
   LodeZlib_DeflateSettings_init(&settings->zlibsettings);
   settings->autoLeaveOutAlphaChannel = 1;
   settings->force_palette = 0;
 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
   settings->add_id = 1;
   settings->text_compression = 0;
 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
 }

unsigned LodePNG_InfoColor_addPalette	(	LodePNG_InfoColor *	info,
		unsigned char	r,
		unsigned char	g,
		unsigned char	b,
		unsigned char	a
	)

Definition at line 2046 of file lodepng.cpp.

 {
   unsigned char* data;
   /*the same resize technique as C++ std::vectors is used, and here it's made so that for a palette with the max of 256 colors, it'll have the exact alloc size*/
   if(!(info->palettesize & (info->palettesize - 1))) /*if palettesize is 0 or a power of two*/
   {
     /*allocated data must be at least 4* palettesize (for 4 color bytes)*/
     size_t alloc_size = info->palettesize == 0 ? 4 : info->palettesize * 4 * 2;
     data = (unsigned char*)realloc(info->palette, alloc_size);
     if(!data) return 9931;
     else info->palette = data;
   }
   info->palette[4 * info->palettesize + 0] = r;
   info->palette[4 * info->palettesize + 1] = g;
   info->palette[4 * info->palettesize + 2] = b;
   info->palette[4 * info->palettesize + 3] = a;
   info->palettesize++;
   return 0;
 }

void LodePNG_InfoColor_cleanup ( LodePNG_InfoColor * info )

Definition at line 2035 of file lodepng.cpp.

 {
   LodePNG_InfoColor_clearPalette(info);
 }

void LodePNG_InfoColor_clearPalette ( LodePNG_InfoColor * info )

Definition at line 2040 of file lodepng.cpp.

 {
   if(info->palette) free(info->palette);
   info->palettesize = 0;
 }

unsigned LodePNG_InfoColor_copy	(	LodePNG_InfoColor *	dest,
		const LodePNG_InfoColor *	source
	)

Definition at line 2323 of file lodepng.cpp.

 {
   size_t i;
   LodePNG_InfoColor_cleanup(dest);
   *dest = *source;
   dest->palette = (unsigned char*)malloc(source->palettesize * 4);
   if(!dest->palette && source->palettesize) return 9935;
   for(i = 0; i < source->palettesize * 4; i++) dest->palette[i] = source->palette[i];
   return 0;
 }

unsigned LodePNG_InfoColor_getBpp ( const LodePNG_InfoColor * info )

Definition at line 2066 of file lodepng.cpp.

2066 { return getBpp(info->colorType, info->bitDepth); } /*calculate bits per pixel out of colorType and bitDepth*/

LodePNG_InfoColor::colorType

unsigned colorType

Definition: lodepng.h:127

LodePNG_InfoColor::bitDepth

unsigned bitDepth

Definition: lodepng.h:128

getBpp

static unsigned getBpp(unsigned colorType, unsigned bitDepth)

Definition: lodepng.cpp:2018

unsigned LodePNG_InfoColor_getChannels ( const LodePNG_InfoColor * info )

Definition at line 2067 of file lodepng.cpp.

2067 { return getNumColorChannels(info->colorType); }

LodePNG_InfoColor::colorType

unsigned colorType

Definition: lodepng.h:127

getNumColorChannels

static unsigned getNumColorChannels(unsigned colorType)

Definition: lodepng.cpp:2005

void LodePNG_InfoColor_init ( LodePNG_InfoColor * info )

Definition at line 2025 of file lodepng.cpp.

 {
   info->key_defined = 0;
   info->key_r = info->key_g = info->key_b = 0;
   info->colorType = 6;
   info->bitDepth = 8;
   info->palette = 0;
   info->palettesize = 0;
 }

unsigned LodePNG_InfoColor_isAlphaType ( const LodePNG_InfoColor * info )

Definition at line 2069 of file lodepng.cpp.

2069 { return (info->colorType & 4) != 0; }

LodePNG_InfoColor::colorType

unsigned colorType

Definition: lodepng.h:127

unsigned LodePNG_InfoColor_isGreyscaleType ( const LodePNG_InfoColor * info )

Definition at line 2068 of file lodepng.cpp.

2068 { return info->colorType == 0 || info->colorType == 4; }

LodePNG_InfoColor::colorType

unsigned colorType

Definition: lodepng.h:127

void LodePNG_InfoPng_cleanup ( LodePNG_InfoPng * info )

Definition at line 2284 of file lodepng.cpp.

 {
   LodePNG_InfoColor_cleanup(&info->color);
 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
   LodePNG_Text_cleanup(&info->text);
   LodePNG_IText_cleanup(&info->itext);
 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
 #ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
   LodePNG_UnknownChunks_cleanup(&info->unknown_chunks);
 #endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
 }

unsigned LodePNG_InfoPng_copy	(	LodePNG_InfoPng *	dest,
		const LodePNG_InfoPng *	source
	)

Definition at line 2296 of file lodepng.cpp.

 {
   unsigned error = 0;
   LodePNG_InfoPng_cleanup(dest);
   *dest = *source;
   LodePNG_InfoColor_init(&dest->color);
   error = LodePNG_InfoColor_copy(&dest->color, &source->color); if(error) return error;
   
 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
   error = LodePNG_Text_copy(&dest->text, &source->text); if(error) return error;
   error = LodePNG_IText_copy(&dest->itext, &source->itext); if(error) return error;
 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
   
 #ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
   LodePNG_UnknownChunks_init(&dest->unknown_chunks);
   error = LodePNG_UnknownChunks_copy(&dest->unknown_chunks, &source->unknown_chunks); if(error) return error;
 #endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
   return error;
 }

void LodePNG_InfoPng_init ( LodePNG_InfoPng * info )

Definition at line 2262 of file lodepng.cpp.

 {
   info->width = info->height = 0;
   LodePNG_InfoColor_init(&info->color);
   info->interlaceMethod = 0;
   info->compressionMethod = 0;
   info->filterMethod = 0;
 #ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
   info->background_defined = 0;
   info->background_r = info->background_g = info->background_b = 0;
   
   LodePNG_Text_init(&info->text);
   LodePNG_IText_init(&info->itext);
   
   info->time_defined = 0;
   info->phys_defined = 0;
 #endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
 #ifdef LODEPNG_COMPILE_UNKNOWN_CHUNKS
   LodePNG_UnknownChunks_init(&info->unknown_chunks);
 #endif /*LODEPNG_COMPILE_UNKNOWN_CHUNKS*/
 }

void LodePNG_InfoRaw_cleanup ( LodePNG_InfoRaw * info )

Definition at line 2339 of file lodepng.cpp.

 {
   LodePNG_InfoColor_cleanup(&info->color);
 }

unsigned LodePNG_InfoRaw_copy	(	LodePNG_InfoRaw *	dest,
		const LodePNG_InfoRaw *	source
	)

Definition at line 2344 of file lodepng.cpp.

 {
   unsigned error = 0;
   LodePNG_InfoRaw_cleanup(dest);
   *dest = *source;
   LodePNG_InfoColor_init(&dest->color);
   error = LodePNG_InfoColor_copy(&dest->color, &source->color);
   return error;
 }

void LodePNG_InfoRaw_init ( LodePNG_InfoRaw * info )

Definition at line 2334 of file lodepng.cpp.

 {
   LodePNG_InfoColor_init(&info->color);
 }

unsigned LodePNG_loadFile	(	unsigned char **	out,
		size_t *	outsize,
		const char *	filename
	)

Definition at line 4110 of file lodepng.cpp.

 {
   FILE* file;
   long size;
   
   /*provide some proper output values if error will happen*/
   *out = 0;
   *outsize = 0;
 
   file = portable_fopen(filename, "rb");
   if(!file) return 78;
 
   /*get filesize:*/
   fseek(file , 0 , SEEK_END);
   size = ftell(file);
   rewind(file);
   
   /*read contents of the file into the vector*/
   if (size>0)
   {
     *outsize = 0;
     *out = (unsigned char*)malloc((size_t)size);
     if(size && (*out)) (*outsize) = fread(*out, 1, (size_t)size, file);
   }
 
   fclose(file);
   if(!(*out) && size) return 80; /*the above malloc failed*/
   return 0;
 }

unsigned LodePNG_saveFile	(	const unsigned char *	buffer,
		size_t	buffersize,
		const char *	filename
	)

Definition at line 4141 of file lodepng.cpp.

 {
   FILE* file;
   file = portable_fopen(filename, "wb" );
   if(!file) return 79;
   fwrite((char*)buffer , 1 , buffersize, file);
   fclose(file);
   return 0;
 }

unsigned LodeZlib_compress	(	unsigned char **	out,
		size_t *	outsize,
		const unsigned char *	in,
		size_t	insize,
		const LodeZlib_DeflateSettings *	settings
	)

Definition at line 1651 of file lodepng.cpp.

 {
   /*initially, *out must be NULL and outsize 0, if you just give some random *out that's pointing to a non allocated buffer, this'll crash*/
   ucvector deflatedata, outv;
   size_t i;
   unsigned error;
   
   unsigned ADLER32;
   /*zlib data: 1 byte CMF (CM+CINFO), 1 byte FLG, deflate data, 4 byte ADLER32 checksum of the Decompressed data*/
   unsigned CMF = 120; /*0b01111000: CM 8, CINFO 7. With CINFO 7, any window size up to 32768 can be used.*/
   unsigned FLEVEL = 0;
   unsigned FDICT = 0;
   unsigned CMFFLG = 256 * CMF + FDICT * 32 + FLEVEL * 64;
   unsigned FCHECK = 31 - CMFFLG % 31;
   CMFFLG += FCHECK;
   
   ucvector_init_buffer(&outv, *out, *outsize); /*ucvector-controlled version of the output buffer, for dynamic array*/
   
   ucvector_push_back(&outv, (unsigned char)(CMFFLG / 256));
   ucvector_push_back(&outv, (unsigned char)(CMFFLG % 256));
   
   ucvector_init(&deflatedata);
   error = LodeFlate_deflate(&deflatedata, in, insize, settings);
   
   if(!error)
   {
     ADLER32 = adler32(in, (unsigned)insize);
     for(i = 0; i < deflatedata.size; i++) ucvector_push_back(&outv, deflatedata.data[i]);
     ucvector_cleanup(&deflatedata);
     LodeZlib_add32bitInt(&outv, ADLER32);
   }
   
   *out = outv.data;
   *outsize = outv.size;
   
   return error;
 }

void LodeZlib_DeflateSettings_init ( LodeZlib_DeflateSettings * settings )

Definition at line 1697 of file lodepng.cpp.

 {
   settings->btype = 2; /*compress with dynamic huffman tree (not in the mathematical sense, just not the predefined one)*/
   settings->useLZ77 = 1;
   settings->windowSize = 2048; /*this is a good tradeoff between speed and compression ratio*/
 }

Variable Documentation

const LodeZlib_DeflateSettings LodeZlib_defaultDeflateSettings

Definition at line 1704 of file lodepng.cpp.

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation