3 Copyright (c) 2003/2004/2005 Matthias Kramm <kramm@quiss.org>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
31 #ifdef PNG_INLINE_EXPORTS
41 unsigned char a,r,g,b;
44 static int png_read_chunk(char (*head)[4], int*destlen, unsigned char**destdata, FILE*fi)
47 unsigned char blen[4];
48 if(destlen) *destlen=0;
49 if(destdata) *destdata=0;
50 if(!fread(&blen, 4, 1, fi)) {
53 if(!fread(head, 4, 1, fi)) {
56 len = blen[0]<<24|blen[1]<<16|blen[2]<<8|blen[3];
57 if(destlen) *destlen = len;
62 *destdata = (unsigned char*)malloc(len);
63 if(!fread(*destdata, len, 1, fi)) {
65 if(destlen) *destlen=0;
69 fseek(fi, 4, SEEK_CUR);
72 fseek(fi, len+4, SEEK_CUR);
77 static unsigned int png_get_dword(FILE*fi)
82 return b[0]<<24|b[1]<<16|b[2]<<8|b[3];
93 static int png_read_header(FILE*fi, struct png_header*header)
98 unsigned char head[8] = {137,80,78,71,13,10,26,10};
99 unsigned char head2[8];
102 if(strncmp((const char*)head,(const char*)head2,4))
103 return 0; // not a png file
105 while(png_read_chunk(&id, &len, &data, fi))
107 //printf("Chunk: %c%c%c%c (len:%d)\n", id[0],id[1],id[2],id[3], len);
108 if(!strncmp(id, "IHDR", 4)) {
111 header->width = data[0]<<24|data[1]<<16|data[2]<<8|data[3];
112 header->height = data[4]<<24|data[5]<<16|data[6]<<8|data[7];
113 a = data[8]; // should be 8
114 b = data[9]; // should be 3(indexed) or 2(rgb)
116 c = data[10]; // compression mode (0)
117 f = data[11]; // filter mode (0)
118 i = data[12]; // interlace mode (0)
120 if(b!=0 && b!=4 && b!=2 && b!=3 && b!=6) {
121 fprintf(stderr, "Image mode %d not supported!\n", b);
124 if(a!=8 && (b==2 || b==6)) {
125 printf("Bpp %d in mode %d not supported!\n", a);
129 printf("Compression mode %d not supported!\n", c);
133 printf("Filter mode %d not supported!\n", f);
137 printf("Interlace mode %d not supported!\n", i);
140 //printf("%dx%d bpp:%d mode:%d comp:%d filter:%d interlace:%d\n",header->width, header->height, a,b,c,f,i);
151 typedef unsigned char byte;
152 #define ABS(a) ((a)>0?(a):(-(a)))
153 static inline byte PaethPredictor (byte a,byte b,byte c)
155 // a = left, b = above, c = upper left
156 int p = a + b - c; // initial estimate
157 int pa = ABS(p - a); // distances to a, b, c
160 // return nearest of a,b,c,
161 // breaking ties in order a,b,c.
162 if (pa <= pb && pa <= pc)
169 static void applyfilter1(int mode, unsigned char*src, unsigned char*old, unsigned char*dest, int width)
172 unsigned char last=0;
173 unsigned char upperlast=0;
176 for(x=0;x<width;x++) {
183 for(x=0;x<width;x++) {
191 for(x=0;x<width;x++) {
199 for(x=0;x<width;x++) {
200 *dest = *src+(*old+last)/2;
208 for(x=0;x<width;x++) {
209 *dest = *src+PaethPredictor(last,*old,upperlast);
220 static void applyfilter2(int mode, unsigned char*src, unsigned char*old, unsigned char*dest, int width)
223 unsigned char lasta=0;
224 unsigned char lastb=0;
225 unsigned char upperlasta=0;
226 unsigned char upperlastb=0;
229 for(x=0;x<width;x++) {
237 for(x=0;x<width;x++) {
238 dest[0] = src[0]+lasta;
239 dest[1] = src[1]+lastb;
247 for(x=0;x<width;x++) {
248 dest[0] = src[0]+old[0];
249 dest[1] = src[1]+old[1];
256 for(x=0;x<width;x++) {
257 dest[0] = src[0]+(old[0]+lasta)/2;
258 dest[1] = src[1]+(old[1]+lastb)/2;
267 for(x=0;x<width;x++) {
268 dest[0] = src[0]+PaethPredictor(lasta,old[0],upperlasta);
269 dest[1] = src[1]+PaethPredictor(lastb,old[1],upperlastb);
282 /* also performs 24 bit conversion! */
283 static void applyfilter3(int mode, unsigned char*src, unsigned char*old, unsigned char*dest, int width)
286 unsigned char lastr=0;
287 unsigned char lastg=0;
288 unsigned char lastb=0;
289 unsigned char upperlastr=0;
290 unsigned char upperlastg=0;
291 unsigned char upperlastb=0;
294 for(x=0;x<width;x++) {
304 for(x=0;x<width;x++) {
306 dest[1] = src[0]+lastr;
307 dest[2] = src[1]+lastg;
308 dest[3] = src[2]+lastb;
317 for(x=0;x<width;x++) {
319 dest[1] = src[0]+old[1];
320 dest[2] = src[1]+old[2];
321 dest[3] = src[2]+old[3];
328 for(x=0;x<width;x++) {
330 dest[1] = src[0]+(old[1]+lastr)/2;
331 dest[2] = src[1]+(old[2]+lastg)/2;
332 dest[3] = src[2]+(old[3]+lastb)/2;
342 for(x=0;x<width;x++) {
344 dest[1] = src[0]+PaethPredictor(lastr,old[1],upperlastr);
345 dest[2] = src[1]+PaethPredictor(lastg,old[2],upperlastg);
346 dest[3] = src[2]+PaethPredictor(lastb,old[3],upperlastb);
360 static void inline applyfilter4(int mode, unsigned char*src, unsigned char*old, unsigned char*dest, int width)
363 unsigned char lastr=0;
364 unsigned char lastg=0;
365 unsigned char lastb=0;
366 unsigned char lasta=0;
367 unsigned char upperlastr=0;
368 unsigned char upperlastg=0;
369 unsigned char upperlastb=0;
370 unsigned char upperlasta=0;
373 for(x=0;x<width;x++) {
383 for(x=0;x<width;x++) {
384 dest[0] = src[3]+lasta;
385 dest[1] = src[0]+lastr;
386 dest[2] = src[1]+lastg;
387 dest[3] = src[2]+lastb;
397 for(x=0;x<width;x++) {
398 dest[0] = src[3]+old[0];
399 dest[1] = src[0]+old[1];
400 dest[2] = src[1]+old[2];
401 dest[3] = src[2]+old[3];
408 for(x=0;x<width;x++) {
409 dest[0] = src[3]+(old[0]+lasta)/2;
410 dest[1] = src[0]+(old[1]+lastr)/2;
411 dest[2] = src[1]+(old[2]+lastg)/2;
412 dest[3] = src[2]+(old[3]+lastb)/2;
423 for(x=0;x<width;x++) {
424 dest[0] = src[3]+PaethPredictor(lasta,old[0],upperlasta);
425 dest[1] = src[0]+PaethPredictor(lastr,old[1],upperlastr);
426 dest[2] = src[1]+PaethPredictor(lastg,old[2],upperlastg);
427 dest[3] = src[2]+PaethPredictor(lastb,old[3],upperlastb);
444 EXPORT int getPNGdimensions(const char*sname, int*destwidth, int*destheight)
447 struct png_header header;
448 if ((fi = fopen(sname, "rb")) == NULL) {
449 fprintf(stderr, "Couldn't open %s\n", sname);
452 if(!png_read_header(fi, &header)) {
456 *destwidth = header.width;
457 *destheight = header.height;
461 EXPORT int getPNG(const char*sname, int*destwidth, int*destheight, unsigned char**destdata)
466 unsigned char*imagedata;
467 unsigned char*zimagedata=0;
468 unsigned long int imagedatalen;
469 unsigned long int zimagedatalen=0;
470 unsigned char*palette = 0;
472 unsigned char*alphapalette = 0;
473 int alphapalettelen = 0;
474 struct png_header header;
476 unsigned char*data2 = 0;
477 unsigned char alphacolor[3];
481 unsigned char *scanline;
483 if ((fi = fopen(sname, "rb")) == NULL) {
484 printf("Couldn't open %s\n", sname);
488 if(!png_read_header(fi, &header)) {
493 if(header.mode == 3 || header.mode == 0) bypp = 1;
494 else if(header.mode == 4) bypp = 2;
495 else if(header.mode == 2) bypp = 3;
496 else if(header.mode == 6) bypp = 4;
498 printf("ERROR: mode:%d\n", header.mode);
502 imagedatalen = bypp * header.width * header.height + 65536;
503 imagedata = (unsigned char*)malloc(imagedatalen);
505 fseek(fi,8,SEEK_SET);
508 if(!png_read_chunk(&tagid, &len, &data, fi))
510 if(!strncmp(tagid, "IEND", 4)) {
513 if(!strncmp(tagid, "PLTE", 4)) {
516 data = 0; //don't free data
517 //printf("%d colors in palette\n", palettelen);
519 if(!strncmp(tagid, "tRNS", 4)) {
520 if(header.mode == 3) {
522 alphapalettelen = len;
523 data = 0; //don't free data
524 //printf("found %d alpha colors\n", alphapalettelen);
525 } else if(header.mode == 0 || header.mode == 2) {
527 if(header.mode == 2) {
528 alphacolor[0] = data[1];
529 alphacolor[1] = data[3];
530 alphacolor[2] = data[5];
532 alphacolor[0] = alphacolor[1] = alphacolor[2] = data[1];
537 if(!strncmp(tagid, "IDAT", 4)) {
540 zimagedata = (unsigned char*)malloc(len);
541 memcpy(zimagedata,data,len);
543 zimagedata = (unsigned char*)realloc(zimagedata, zimagedatalen+len);
544 memcpy(&zimagedata[zimagedatalen], data, len);
545 zimagedatalen += len;
548 if(!strncmp(tagid, "tEXt", 4)) {
550 printf("Image Text: ");
552 if(data[t]>=32 && data[t]<128)
553 printf("%c", data[t]);
564 if(!zimagedata || uncompress(imagedata, &imagedatalen, zimagedata, zimagedatalen) != Z_OK) {
565 printf("Couldn't uncompress %s!\n", sname);
573 *destwidth = header.width;
574 *destheight = header.height;
576 data2 = (unsigned char*)malloc(header.width*header.height*4);
583 unsigned char* old= (unsigned char*)malloc(header.width*2);
584 memset(old, 0, header.width*2);
586 for(y=0;y<header.height;y++) {
587 int mode = imagedata[pos++]; //filter mode
591 dest = &data2[(y*header.width)*4];
593 if(header.bpp == 8) {
594 /* one byte per pixel */
595 src = &imagedata[pos];
598 /* not implemented yet */
599 fprintf(stderr, "ERROR: mode=4 bpp:%d\n", header.bpp);
604 applyfilter2(mode, src, old, dest, header.width);
605 memcpy(old, dest, header.width*2);
607 for(x=header.width-1;x>=0;x--) {
608 unsigned char gray = dest[x*2+0];
609 unsigned char alpha = dest[x*2+1];
618 } else if(header.mode == 6 || header.mode == 2) {
624 unsigned char* firstline = malloc(header.width*4);
625 memset(firstline,0,header.width*4);
626 for(y=0;y<header.height;y++) {
627 int mode = imagedata[pos++]; //filter mode
631 dest = &data2[(y*header.width)*4];
635 /* one byte per pixel */
636 src = &imagedata[pos];
637 pos+=header.width*(header.mode==6?4:3);
639 /* not implemented yet */
640 fprintf(stderr, "ERROR: bpp:%d\n", header.bpp);
648 old = &data2[(y-1)*header.width*4];
650 if(header.mode == 6) {
651 applyfilter4(mode, src, old, dest, header.width);
652 } else { // header.mode = 2
653 applyfilter3(mode, src, old, dest, header.width);
654 /* replace alpha color */
657 for(x=0;x<header.width;x++) {
658 if(dest[x*4+1] == alphacolor[0] &&
659 dest[x*4+2] == alphacolor[1] &&
660 dest[x*4+3] == alphacolor[2]) {
661 *(u32*)&dest[x*4] = 0;
669 } else if(header.mode == 0 || header.mode == 3) {
671 unsigned char*tmpline = (unsigned char*)malloc(header.width+1);
672 unsigned char*destline = (unsigned char*)malloc(header.width+1);
678 if(header.mode == 0) { // grayscale palette
679 int mult = (0x1ff>>header.bpp);
680 palettelen = 1<<header.bpp;
681 rgba = (COL*)malloc(palettelen*sizeof(COL));
682 for(i=0;i<palettelen;i++) {
688 if(rgba[i].r == alphacolor[0])
694 fprintf(stderr, "Error: No palette found!\n");
697 rgba = (COL*)malloc(palettelen*4);
698 /* 24->32 bit conversion */
699 for(i=0;i<palettelen;i++) {
700 rgba[i].r = palette[i*3+0];
701 rgba[i].g = palette[i*3+1];
702 rgba[i].b = palette[i*3+2];
703 if(alphapalette && i<alphapalettelen) {
704 rgba[i].a = alphapalette[i];
705 /*rgba[i].r = ((int)rgba[i].r*rgba[i].a)/255;
706 rgba[i].g = ((int)rgba[i].g*rgba[i].a)/255;
707 rgba[i].b = ((int)rgba[i].b*rgba[i].a)/255;*/
712 if(rgba[i].r == alphacolor[0] &&
713 rgba[i].g == alphacolor[1] &&
714 rgba[i].b == alphacolor[2])
720 for(y=0;y<header.height;y++) {
721 int mode = imagedata[pos++]; //filter mode
725 src = &imagedata[pos];
726 if(header.bpp == 8) {
731 u32 v = (1<<header.bpp)-1;
732 for(x=0;x<header.width;x++) {
733 u32 r = src[s/8]<<8 |
736 tmpline[x] = (r>>(16-header.bpp-(s&7)))&v;
740 pos+=(header.width*header.bpp+7)/8;
744 memset(destline,0,header.width);
745 old = &destline[y*header.width];
749 applyfilter1(mode, src, old, destline, header.width);
750 memcpy(tmpline,destline,header.width);
751 for(x=0;x<header.width;x++) {
752 *(COL*)&data2[y*header.width*4+x*4+0] = rgba[destline[x]];
760 printf("expected PNG mode to be 2, 3 or 6 (is:%d)\n", header.mode);
767 static char hasAlpha(unsigned char*_image, int size)
769 COL*image = (COL*)_image;
771 for(t=0;t<size;t++) {
783 static int compare_colors(const void*_c1, const void*_c2) {
784 colornum_t*c1 = (colornum_t*)_c1;
785 colornum_t*c2 = (colornum_t*)_c2;
786 return c2->num - c1->num;
789 static colornum_t* getColors(COL*image, int size, int*num)
791 unsigned char*colexists = malloc((256*256*256)/8);
792 memset(colexists, 0, (256*256*256)/8);
796 /* find all different colors in the image */
797 for(t=0;t<size;t++) {
798 int index = (image[t].r)|(image[t].g)<<8|(image[t].b)<<16;
799 if(!(colexists[index/8]&(1<<(index&7)))) {
801 colexists[index/8]|=(1<<(index&7));
805 /* now store them in an array */
806 colornum_t*colors=(colornum_t*)malloc(sizeof(colornum_t)*count);
808 for(t=0;t<256*256*256;t++) {
809 if(colexists[t/8]&(1<<(t&7))) {
810 colors[pos].color = t;
816 /* next, count how often each color occurs */
817 for(t=0;t<size;t++) {
818 int col = (image[t].r)|(image[t].g)<<8|(image[t].b)<<16;
820 for(min=0, max=count, i=count/2, l=count; i != l; l=i,i=(min+max)/2) {
822 if(colors[i].color >= col) max=i;
825 assert(colors[i].color==col);
833 static COL* getOptimalPalette(COL*image, int size, int palettesize)
836 COL* ret = malloc(sizeof(COL)*palettesize);
837 memset(ret, 0, sizeof(COL)*palettesize);
838 colornum_t*colors = getColors(image, size, &num);
840 assert(palettesize<=256);
842 qsort(colors, num, sizeof(colornum_t), compare_colors);
844 if(num<=palettesize) {
845 /* if there are not more than palettesize different colors in
846 the image anyway, we are done */
849 ret[t].r = colors[t].color;
850 ret[t].g = colors[t].color>>8;
851 ret[t].b = colors[t].color>>16;
858 /* if there are too many different colors, pick the ones that
863 colornum_t*centers = malloc(sizeof(colornum_t)*palettesize);
865 for(t=0;t<palettesize;t++) {
866 centers[t].color = colors[t].color;
868 unsigned char*belongsto = (unsigned char*)malloc(num);
869 memset(belongsto, 0, num);
870 /* do a k-means clustering on the colors */
874 if(tries++ >= (palettesize+num)*2) {
875 fprintf(stderr, "Warning: didn't find optimal palette\n");
880 for(s=0;s<palettesize;s++) {
886 for(s=0;s<palettesize;s++) {
888 distance += abs((centers[s].color>>0&0xff) - (colors[t].color>>0&0xff));
889 distance += abs((centers[s].color>>8&0xff) - (colors[t].color>>8&0xff));
890 distance += abs((centers[s].color>>16&0xff) - (colors[t].color>>16&0xff));
891 distance *= colors[t].num;
897 if(bestpos!=belongsto[t])
899 belongsto[t] = bestpos;
901 for(s=0;s<palettesize;s++) {
907 if(belongsto[t]==s) {
908 r += ((colors[t].color>>0)&0xff)*colors[t].num;
909 g += ((colors[t].color>>8)&0xff)*colors[t].num;
910 b += ((colors[t].color>>16)&0xff)*colors[t].num;
911 count+=colors[t].num;
915 int random = rand()%num;
916 centers[s].color = colors[random].color;
923 centers[s].color = r|g<<8|b<<16;
924 centers[s].num = count;
930 for(t=0;t<palettesize;t++) {
931 ret[t].r = centers[t].color;
932 ret[t].g = centers[t].color>>8;
933 ret[t].b = centers[t].color>>16;
940 static int sqr(const int x) {return x*x;}
942 static void quantizeImage(unsigned char*_image, int size, int numcolors, unsigned char**newimage, COL**palette)
944 COL*image = (COL*)_image;
945 COL*pal= getOptimalPalette(image, size, numcolors);
947 *newimage = (unsigned char*)malloc(size);
949 for(t=0;t<size;t++) {
953 for(s=0;s<numcolors;s++) {
955 distance += sqr((pal[s].r) - (image[t].r))*5;
956 distance += sqr((pal[s].g) - (image[t].g))*6;
957 distance += sqr((pal[s].b) - (image[t].b))*4;
963 //image[t] = pal[bestcol];
964 (*newimage)[t] = bestcol;
970 static u32*crc32_table = 0;
971 static void make_crc32_table(void)
976 crc32_table = (u32*)malloc(1024);
978 for (t = 0; t < 256; t++) {
981 for (s = 0; s < 8; s++) {
982 c = (0xedb88320L*(c&1)) ^ (c >> 1);
987 static inline void png_write_byte(FILE*fi, unsigned char byte)
989 fwrite(&byte,1,1,fi);
990 mycrc32 = crc32_table[(mycrc32 ^ byte) & 0xff] ^ (mycrc32 >> 8);
992 static long png_start_chunk(FILE*fi, char*type, int len)
994 unsigned char mytype[4]={0,0,0,0};
995 unsigned char mylen[4];
1001 memcpy(mytype,type,strlen(type));
1002 filepos = ftell(fi);
1003 fwrite(&mylen, 4, 1, fi);
1005 png_write_byte(fi,mytype[0]);
1006 png_write_byte(fi,mytype[1]);
1007 png_write_byte(fi,mytype[2]);
1008 png_write_byte(fi,mytype[3]);
1011 static void png_patch_len(FILE*fi, int pos, int len)
1013 unsigned char mylen[4];
1019 fseek(fi, pos, SEEK_SET);
1020 fwrite(&mylen, 4, 1, fi);
1021 fseek(fi, 0, SEEK_END);
1023 static void png_write_bytes(FILE*fi, unsigned char*bytes, int len)
1027 png_write_byte(fi,bytes[t]);
1029 static void png_write_dword(FILE*fi, u32 dword)
1031 png_write_byte(fi,dword>>24);
1032 png_write_byte(fi,dword>>16);
1033 png_write_byte(fi,dword>>8);
1034 png_write_byte(fi,dword);
1036 static void png_end_chunk(FILE*fi)
1038 u32 tmp = mycrc32^0xffffffff;
1039 unsigned char tmp2[4];
1044 fwrite(&tmp2,4,1,fi);
1047 #define ZLIB_BUFFER_SIZE 16384
1049 static long compress_line(z_stream*zs, Bytef*line, int len, FILE*fi)
1056 int ret = deflate(zs, Z_NO_FLUSH);
1058 fprintf(stderr, "error in deflate(): %s", zs->msg?zs->msg:"unknown");
1061 if(zs->avail_out != ZLIB_BUFFER_SIZE) {
1062 int consumed = ZLIB_BUFFER_SIZE - zs->avail_out;
1064 png_write_bytes(fi, zs->next_out - consumed , consumed);
1065 zs->next_out = zs->next_out - consumed;
1066 zs->avail_out = ZLIB_BUFFER_SIZE;
1075 static int test_line(z_stream*zs_orig, Bytef*line, int linelen)
1078 int ret = deflateCopy(&zs, zs_orig);
1080 fprintf(stderr, "Couldn't copy stream\n");
1085 zs.avail_in = linelen;
1089 int mode = Z_SYNC_FLUSH;
1091 int ret = deflate(&zs, mode);
1092 if (ret != Z_OK && ret != Z_STREAM_END) {
1093 fprintf(stderr, "error in deflate(): %s (mode %s, %d bytes remaining)\n", zs.msg?zs.msg:"unknown",
1094 mode==Z_SYNC_FLUSH?"Z_SYNC_FLUSH":"Z_FINISH", zs.avail_in);
1097 if(zs.avail_out != ZLIB_BUFFER_SIZE) {
1098 int consumed = ZLIB_BUFFER_SIZE - zs.avail_out;
1100 zs.next_out = zs.next_out - consumed;
1101 zs.avail_out = ZLIB_BUFFER_SIZE;
1103 if (ret == Z_STREAM_END) {
1110 ret = deflateEnd(&zs);
1112 fprintf(stderr, "error in deflateEnd(): %s\n", zs.msg?zs.msg:"unknown");
1118 static int finishzlib(z_stream*zs, FILE*fi)
1123 ret = deflate(zs, Z_FINISH);
1125 ret != Z_STREAM_END) {
1126 fprintf(stderr, "error in deflate(finish): %s\n", zs->msg?zs->msg:"unknown");
1130 if(zs->avail_out != ZLIB_BUFFER_SIZE) {
1131 int consumed = ZLIB_BUFFER_SIZE - zs->avail_out;
1133 png_write_bytes(fi, zs->next_out - consumed , consumed);
1134 zs->next_out = zs->next_out - consumed;
1135 zs->avail_out = ZLIB_BUFFER_SIZE;
1137 if (ret == Z_STREAM_END) {
1141 ret = deflateEnd(zs);
1143 fprintf(stderr, "error in deflateEnd(): %s\n", zs->msg?zs->msg:"unknown");
1149 static void filter_line8(int filtermode, unsigned char*dest, unsigned char*src, int width)
1153 int srcwidth = width;
1155 if(filtermode == 0) {
1156 for(x=0;x<width;x++) {
1157 dest[pos2++]=src[pos++]; //alpha
1159 } else if(filtermode == 1) {
1160 /* x difference filter */
1161 dest[pos2++]=src[pos++];
1162 for(x=1;x<width;x++) {
1163 dest[pos2++]=src[pos] - src[pos-1];
1166 } else if(filtermode == 2) {
1167 /* y difference filter */
1168 for(x=0;x<width;x++) {
1169 dest[pos2++]=src[pos+0] - src[pos-srcwidth+0]; //alpha
1172 } else if(filtermode == 3) {
1173 dest[pos2++]=src[pos+0] - src[pos-srcwidth+0]/2;
1175 /* x+y difference filter */
1176 for(x=1;x<width;x++) {
1177 dest[pos2++]=src[pos+0] - (src[pos-1+0] + src[pos-srcwidth+0])/2; //alpha
1180 } else if(filtermode == 4) {
1181 dest[pos2++]=src[pos+0] - PaethPredictor(0, src[pos-srcwidth+0], 0);
1183 /* paeth difference filter */
1184 for(x=1;x<width;x++) {
1185 dest[pos2++]=src[pos+0] - PaethPredictor(src[pos-1+0], src[pos-srcwidth+0], src[pos-1-srcwidth+0]);
1191 static void filter_line32(int filtermode, unsigned char*dest, unsigned char*src, int width)
1195 int srcwidth = width*4;
1197 if(filtermode == 0) {
1198 for(x=0;x<width;x++) {
1199 dest[pos2++]=src[pos+1];
1200 dest[pos2++]=src[pos+2];
1201 dest[pos2++]=src[pos+3];
1202 dest[pos2++]=src[pos+0]; //alpha
1205 } else if(filtermode == 1) {
1206 /* x difference filter */
1207 dest[pos2++]=src[pos+1];
1208 dest[pos2++]=src[pos+2];
1209 dest[pos2++]=src[pos+3];
1210 dest[pos2++]=src[pos+0];
1212 for(x=1;x<width;x++) {
1213 dest[pos2++]=src[pos+1] - src[pos-4+1];
1214 dest[pos2++]=src[pos+2] - src[pos-4+2];
1215 dest[pos2++]=src[pos+3] - src[pos-4+3];
1216 dest[pos2++]=src[pos+0] - src[pos-4+0]; //alpha
1219 } else if(filtermode == 2) {
1220 /* y difference filter */
1221 for(x=0;x<width;x++) {
1222 dest[pos2++]=src[pos+1] - src[pos-srcwidth+1];
1223 dest[pos2++]=src[pos+2] - src[pos-srcwidth+2];
1224 dest[pos2++]=src[pos+3] - src[pos-srcwidth+3];
1225 dest[pos2++]=src[pos+0] - src[pos-srcwidth+0]; //alpha
1228 } else if(filtermode == 3) {
1229 dest[pos2++]=src[pos+1] - src[pos-srcwidth+1]/2;
1230 dest[pos2++]=src[pos+2] - src[pos-srcwidth+2]/2;
1231 dest[pos2++]=src[pos+3] - src[pos-srcwidth+3]/2;
1232 dest[pos2++]=src[pos+0] - src[pos-srcwidth+0]/2;
1234 /* x+y difference filter */
1235 for(x=1;x<width;x++) {
1236 dest[pos2++]=src[pos+1] - (src[pos-4+1] + src[pos-srcwidth+1])/2;
1237 dest[pos2++]=src[pos+2] - (src[pos-4+2] + src[pos-srcwidth+2])/2;
1238 dest[pos2++]=src[pos+3] - (src[pos-4+3] + src[pos-srcwidth+3])/2;
1239 dest[pos2++]=src[pos+0] - (src[pos-4+0] + src[pos-srcwidth+0])/2; //alpha
1242 } else if(filtermode == 4) {
1243 dest[pos2++]=src[pos+1] - PaethPredictor(0, src[pos-srcwidth+1], 0);
1244 dest[pos2++]=src[pos+2] - PaethPredictor(0, src[pos-srcwidth+2], 0);
1245 dest[pos2++]=src[pos+3] - PaethPredictor(0, src[pos-srcwidth+3], 0);
1246 dest[pos2++]=src[pos+0] - PaethPredictor(0, src[pos-srcwidth+0], 0);
1248 /* paeth difference filter */
1249 for(x=1;x<width;x++) {
1250 dest[pos2++]=src[pos+1] - PaethPredictor(src[pos-4+1], src[pos-srcwidth+1], src[pos-4-srcwidth+1]);
1251 dest[pos2++]=src[pos+2] - PaethPredictor(src[pos-4+2], src[pos-srcwidth+2], src[pos-4-srcwidth+2]);
1252 dest[pos2++]=src[pos+3] - PaethPredictor(src[pos-4+3], src[pos-srcwidth+3], src[pos-4-srcwidth+3]);
1253 dest[pos2++]=src[pos+0] - PaethPredictor(src[pos-4+0], src[pos-srcwidth+0], src[pos-4-srcwidth+0]);
1259 EXPORT void savePNG(const char*filename, unsigned char*data, int width, int height, int numcolors)
1264 unsigned char format;
1266 unsigned char* data2=0;
1269 unsigned char head[] = {137,80,78,71,13,10,26,10}; // PNG header
1290 quantizeImage(data, width*height, numcolors, &data, &palette);
1293 datalen = (width*height*bpp/8+cols*8);
1295 fi = fopen(filename, "wb");
1300 fwrite(head,sizeof(head),1,fi);
1302 png_start_chunk(fi, "IHDR", 13);
1303 png_write_dword(fi,width);
1304 png_write_dword(fi,height);
1305 png_write_byte(fi,8);
1307 png_write_byte(fi,3); //indexed
1308 else if(format == 5 && alpha==0)
1309 png_write_byte(fi,2); //rgb
1310 else if(format == 5 && alpha==1)
1311 png_write_byte(fi,6); //rgba
1314 png_write_byte(fi,0); //compression mode
1315 png_write_byte(fi,0); //filter mode
1316 png_write_byte(fi,0); //interlace mode
1320 png_start_chunk(fi, "PLTE", 768);
1321 for(t=0;t<cols;t++) {
1322 png_write_byte(fi,palette[t].r);
1323 png_write_byte(fi,palette[t].g);
1324 png_write_byte(fi,palette[t].b);
1328 long idatpos = png_start_chunk(fi, "IDAT", 0);
1330 memset(&zs,0,sizeof(z_stream));
1331 Bytef*writebuf = (Bytef*)malloc(ZLIB_BUFFER_SIZE);
1335 zs.next_out = writebuf;
1336 zs.avail_out = ZLIB_BUFFER_SIZE;
1337 ret = deflateInit(&zs, 9);
1339 fprintf(stderr, "error in deflateInit(): %s", zs.msg?zs.msg:"unknown");
1347 int srcwidth = width * bypp;
1348 int linelen = 1 + srcwidth;
1350 linelen = 1 + ((srcwidth+1)&~1);
1352 linelen = 1 + ((srcwidth+2)/3)*3;
1354 linelen = 1 + ((srcwidth+3)&~3);
1355 unsigned char* line = (unsigned char*)malloc(linelen);
1356 unsigned char* bestline = (unsigned char*)malloc(linelen);
1357 memset(line, 0, linelen);
1358 for(y=0;y<height;y++)
1361 int bestsize = 0x7fffffff;
1362 for(filtermode=0;filtermode<=0;filtermode++) {
1363 if(!y && filtermode>=2)
1364 continue; // don't do y direction filters in the first row
1366 line[0]=filtermode; //filter type
1368 filter_line8(filtermode, line+1, &data[y*srcwidth], width);
1370 filter_line32(filtermode, line+1, &data[y*srcwidth], width);
1372 int size = test_line(&zs, line, linelen);
1373 if(size < bestsize) {
1374 memcpy(bestline, line, linelen);
1378 idatsize += compress_line(&zs, bestline, linelen, fi);
1380 free(line);free(bestline);
1382 idatsize += finishzlib(&zs, fi);
1383 png_patch_len(fi, idatpos, idatsize);
1386 png_start_chunk(fi, "IEND", 0);
1394 EXPORT void writePNG(const char*filename, unsigned char*data, int width, int height)
1396 savePNG(filename, data, width, height, 0);
1398 EXPORT void writePalettePNG(const char*filename, unsigned char*data, int width, int height)
1400 savePNG(filename, data, width, height, 256);