[python-pillow] Add patches to fix build on bigendian
Sandro Mani
smani at fedoraproject.org
Sun Apr 7 23:08:18 UTC 2013
commit da3613d08948dda9e6597bc47cb1b0ffc641b582
Author: Sandro Mani <manisandro at gmail.com>
Date: Mon Apr 8 01:09:51 2013 +0200
Add patches to fix build on bigendian
python-pillow.spec | 13 +-
python-pillow_endianness.patch | 58 ++
python-pillow_quantization.patch | 1791 ++++++++++++++++++++++++++++++++++++++
3 files changed, 1859 insertions(+), 3 deletions(-)
---
diff --git a/python-pillow.spec b/python-pillow.spec
index ea9d9cc..57af24f 100644
--- a/python-pillow.spec
+++ b/python-pillow.spec
@@ -17,7 +17,7 @@
Name: python-pillow
Version: 2.0.0
-Release: 4%{?snap}%{?dist}
+Release: 5%{?snap}%{?dist}
Summary: Python 2 image processing library
# License: see http://www.pythonware.com/products/pil/license.htm
@@ -30,6 +30,10 @@ Source0: https://github.com/python-imaging/Pillow/tarball/%{commit}/pytho
# Add s390* and ppc* archs
Patch0: python-pillow-archs.patch
+# Fix quantization code
+Patch1: python-pillow_quantization.patch
+# Fix tests which are hardcoded for little-endian CPUs
+Patch2: python-pillow_endianness.patch
BuildRequires: python2-devel
BuildRequires: python-setuptools
@@ -169,6 +173,8 @@ Tk interface for %{name3}.
%prep
%setup -q -n python-imaging-Pillow-%{shortcommit}
%patch0 -p1 -b .archs
+%patch1 -p1 -b .quant
+%patch2 -p1 -b .endian
%if %{with_python3}
# Create Python 3 source tree
@@ -237,7 +243,6 @@ rm -rf $RPM_BUILD_ROOT%{_bindir}
%check
-%ifnarch ppc %{power64} s390 s390x
# Check Python 2 modules
ln -s $PWD/Images $RPM_BUILD_ROOT%{python_sitearch}/Images
ln -s $PWD/Tests $RPM_BUILD_ROOT%{python_sitearch}/Tests
@@ -265,7 +270,6 @@ rm $RPM_BUILD_ROOT%{python3_sitearch}/Tests
rm $RPM_BUILD_ROOT%{python3_sitearch}/selftest.py*
popd
%endif
-%endif
%files
@@ -317,6 +321,9 @@ popd
%endif
%changelog
+* Mon Apr 08 2013 Sandro Mani <manisandro at gmail.com> - 2.0.0-5.git93a488e
+- Reenable tests on bigendian, add patches for #928927
+
* Sun Apr 07 2013 Sandro Mani <manisandro at gmail.com> - 2.0.0-4.git93a488e
- Update to latest git
- disable tests on bigendian (PPC*, S390*) until rhbz#928927 is fixed
diff --git a/python-pillow_endianness.patch b/python-pillow_endianness.patch
new file mode 100644
index 0000000..7f87e50
--- /dev/null
+++ b/python-pillow_endianness.patch
@@ -0,0 +1,58 @@
+diff --git a/Tests/test_image_array.py b/Tests/test_image_array.py
+index c2e8590..351621d 100644
+--- a/Tests/test_image_array.py
++++ b/Tests/test_image_array.py
+@@ -10,8 +10,8 @@ def test(mode):
+ return ai["shape"], ai["typestr"], len(ai["data"])
+ # assert_equal(test("1"), ((100, 128), '|b1', 1600))
+ assert_equal(test("L"), ((100, 128), '|u1', 12800))
+- assert_equal(test("I"), ((100, 128), '<i4', 51200)) # FIXME: wrong?
+- assert_equal(test("F"), ((100, 128), '<f4', 51200)) # FIXME: wrong?
++ assert_equal(test("I"), ((100, 128), Image._ENDIAN + 'i4', 51200)) # FIXME: wrong?
++ assert_equal(test("F"), ((100, 128), Image._ENDIAN + 'f4', 51200)) # FIXME: wrong?
+ assert_equal(test("RGB"), ((100, 128, 3), '|u1', 38400))
+ assert_equal(test("RGBA"), ((100, 128, 4), '|u1', 51200))
+ assert_equal(test("RGBX"), ((100, 128, 4), '|u1', 51200))
+diff --git a/Tests/test_lib_pack.py b/Tests/test_lib_pack.py
+index 5bf622c..b3355b6 100644
+--- a/Tests/test_lib_pack.py
++++ b/Tests/test_lib_pack.py
+@@ -18,6 +18,8 @@ def pack(mode, rawmode):
+ else:
+ return [ord(c) for c in im.tobytes("raw", rawmode)]
+
++ order = 1 if Image._ENDIAN == '<' else -1
++
+ assert_equal(pack("1", "1"), [128])
+ assert_equal(pack("1", "1;I"), [0])
+ assert_equal(pack("1", "1;R"), [1])
+@@ -25,9 +27,9 @@ def pack(mode, rawmode):
+
+ assert_equal(pack("L", "L"), [1])
+
+- assert_equal(pack("I", "I"), [1, 0, 0, 0])
++ assert_equal(pack("I", "I"), [1, 0, 0, 0][::order])
+
+- assert_equal(pack("F", "F"), [0, 0, 128, 63])
++ assert_equal(pack("F", "F"), [0, 0, 128, 63][::order])
+
+ assert_equal(pack("LA", "LA"), [1, 2])
+
+diff --git a/Tests/test_mode_i16.py b/Tests/test_mode_i16.py
+index 584bdd9..4c17985 100644
+--- a/Tests/test_mode_i16.py
++++ b/Tests/test_mode_i16.py
+@@ -84,10 +84,12 @@ def test_tobytes():
+ def tobytes(mode):
+ return Image.new(mode, (1, 1), 1).tobytes()
+
++ order = 1 if Image._ENDIAN == '<' else -1
++
+ assert_equal(tobytes("L"), b"\x01")
+ assert_equal(tobytes("I;16"), b"\x01\x00")
+ assert_equal(tobytes("I;16B"), b"\x00\x01")
+- assert_equal(tobytes("I"), b"\x01\x00\x00\x00")
++ assert_equal(tobytes("I"), b"\x01\x00\x00\x00"[::order])
+
+
+ def test_convert():
diff --git a/python-pillow_quantization.patch b/python-pillow_quantization.patch
new file mode 100644
index 0000000..af801ce
--- /dev/null
+++ b/python-pillow_quantization.patch
@@ -0,0 +1,1791 @@
+diff --git a/_imaging.c b/_imaging.c
+index c9d3c82..2ee7eef 100644
+--- a/_imaging.c
++++ b/_imaging.c
+@@ -1369,7 +1369,6 @@ _putdata(ImagingObject* self, PyObject* args)
+
+ #ifdef WITH_QUANTIZE
+
+-#include "Quant.h"
+ static PyObject*
+ _quantize(ImagingObject* self, PyObject* args)
+ {
+diff --git a/libImaging/Quant.c b/libImaging/Quant.c
+index ff15ac0..7f328bd 100644
+--- a/libImaging/Quant.c
++++ b/libImaging/Quant.c
+@@ -25,17 +25,15 @@
+ #include <memory.h>
+ #include <time.h>
+
+-#include "Quant.h"
++#include "QuantTypes.h"
+ #include "QuantOctree.h"
+-
+-#include "QuantDefines.h"
+ #include "QuantHash.h"
+ #include "QuantHeap.h"
+
+ #define NO_OUTPUT
+
+ typedef struct {
+- unsigned long scale;
++ uint32_t scale;
+ } PixelHashData;
+
+ typedef struct _PixelList {
+@@ -50,7 +48,7 @@ typedef struct _BoxNode {
+ PixelList *head[3],*tail[3];
+ int axis;
+ int volume;
+- unsigned long pixelCount;
++ uint32_t pixelCount;
+ } BoxNode;
+
+ #define _SQR(x) ((x)*(x))
+@@ -76,104 +74,92 @@ typedef struct _BoxNode {
+ ((q)->c.g=(p)->c.g>>(s)), \
+ ((q)->c.b=(p)->c.b>>(s))
+
+-static unsigned long
+-unshifted_pixel_hash(const HashTable h, const void *p)
++static uint32_t
++unshifted_pixel_hash(const HashTable *h, const Pixel pixel)
+ {
+- Pixel *pixel=(Pixel *)&p;
+- unsigned long hash=PIXEL_HASH(pixel->c.r,
+- pixel->c.g,
+- pixel->c.b);
+- return hash;
++ return PIXEL_HASH(pixel.c.r, pixel.c.g, pixel.c.b);
+ }
+
+ static int
+-unshifted_pixel_cmp(const HashTable h, const void *a, const void *b)
++unshifted_pixel_cmp(const HashTable *h, const Pixel pixel1, const Pixel pixel2)
+ {
+- Pixel *pixel1=(Pixel *)&a;
+- Pixel *pixel2=(Pixel *)&b;
+- if (pixel1->c.r==pixel2->c.r) {
+- if (pixel1->c.g==pixel2->c.g) {
+- if (pixel1->c.b==pixel2->c.b) {
++ if (pixel1.c.r==pixel2.c.r) {
++ if (pixel1.c.g==pixel2.c.g) {
++ if (pixel1.c.b==pixel2.c.b) {
+ return 0;
+ } else {
+- return (int)(pixel1->c.b)-(int)(pixel2->c.b);
++ return (int)(pixel1.c.b)-(int)(pixel2.c.b);
+ }
+ } else {
+- return (int)(pixel1->c.g)-(int)(pixel2->c.g);
++ return (int)(pixel1.c.g)-(int)(pixel2.c.g);
+ }
+ } else {
+- return (int)(pixel1->c.r)-(int)(pixel2->c.r);
++ return (int)(pixel1.c.r)-(int)(pixel2.c.r);
+ }
+ }
+
+-static unsigned long
+-pixel_hash(const HashTable h,const void *p)
++static uint32_t
++pixel_hash(const HashTable *h,const Pixel pixel)
+ {
+ PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
+- Pixel *pixel=(Pixel *)&p;
+- unsigned long hash=PIXEL_HASH(pixel->c.r>>d->scale,
+- pixel->c.g>>d->scale,
+- pixel->c.b>>d->scale);
+- return hash;
++ return PIXEL_HASH(pixel.c.r>>d->scale, pixel.c.g>>d->scale, pixel.c.b>>d->scale);
+ }
+
+ static int
+-pixel_cmp(const HashTable h,const void *a,const void *b)
++pixel_cmp(const HashTable *h,const Pixel pixel1, const Pixel pixel2)
+ {
+ PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
+- Pixel *pixel1=(Pixel *)&a;
+- Pixel *pixel2=(Pixel *)&b;
+- unsigned long A,B;
+- A=PIXEL_HASH(pixel1->c.r>>d->scale,
+- pixel1->c.g>>d->scale,
+- pixel1->c.b>>d->scale);
+- B=PIXEL_HASH(pixel2->c.r>>d->scale,
+- pixel2->c.g>>d->scale,
+- pixel2->c.b>>d->scale);
++ uint32_t A,B;
++ A=PIXEL_HASH(pixel1.c.r>>d->scale, pixel1.c.g>>d->scale, pixel1.c.b>>d->scale);
++ B=PIXEL_HASH(pixel2.c.r>>d->scale, pixel2.c.g>>d->scale, pixel2.c.b>>d->scale);
+ return (A==B)?0:((A<B)?-1:1);
+ }
+
+ static void
+-exists_count_func(const HashTable h, const void *key, void **val)
++exists_count_func(const HashTable *h, const Pixel key, uint32_t *val)
+ {
+- *(unsigned long*)val+=1;
++ *val+=1;
+ }
+
+ static void
+-new_count_func(const HashTable h, const void *key, void **val)
++new_count_func(const HashTable *h, const Pixel key, uint32_t *val)
+ {
+- *(unsigned long*)val=1;
++ *val=1;
+ }
+
+ static void
+-rehash_collide(HashTable h,
+- void **keyp,
+- void **valp,
+- void *newkey,
+- void *newval)
++rehash_collide(const HashTable *h,
++ Pixel *keyp,
++ uint32_t *valp,
++ Pixel newkey,
++ uint32_t newval)
+ {
+- *valp = (void *)(((unsigned long) *valp) + ((unsigned long) newval));
++ *valp += newval;
+ }
+
+ /* %% */
+
+-static HashTable
+-create_pixel_hash(Pixel *pixelData,unsigned long nPixels)
++static HashTable *
++create_pixel_hash(Pixel *pixelData,uint32_t nPixels)
+ {
+ PixelHashData *d;
+ HashTable *hash;
+- unsigned long i;
+- unsigned long timer,timer2,timer3;
++ uint32_t i;
++#ifndef NO_OUTPUT
++ uint32_t timer,timer2,timer3;
++#endif
+
+ d=malloc(sizeof(PixelHashData));
+ if (!d) return NULL;
+ hash=hashtable_new(pixel_hash,pixel_cmp);
+ hashtable_set_user_data(hash,d);
+ d->scale=0;
++#ifndef NO_OUTPUT
+ timer=timer3=clock();
++#endif
+ for (i=0;i<nPixels;i++) {
+ if (!hashtable_insert_or_update_computed(hash,
+- (void *)pixelData[i].v,
++ pixelData[i],
+ new_count_func,
+ exists_count_func)) {;
+ }
+@@ -181,14 +167,14 @@ create_pixel_hash(Pixel *pixelData,unsigned long nPixels)
+ d->scale++;
+ #ifndef NO_OUTPUT
+ printf ("rehashing - new scale: %d\n",(int)d->scale);
+-#endif
+ timer2=clock();
++#endif
+ hashtable_rehash_compute(hash,rehash_collide);
+- timer2=clock()-timer2;
+ #ifndef NO_OUTPUT
++ timer2=clock()-timer2;
+ printf ("rehash took %f sec\n",timer2/(double)CLOCKS_PER_SEC);
+-#endif
+ timer+=timer2;
++#endif
+ }
+ }
+ #ifndef NO_OUTPUT
+@@ -201,7 +187,7 @@ create_pixel_hash(Pixel *pixelData,unsigned long nPixels)
+ }
+
+ static void
+-destroy_pixel_hash(HashTable hash)
++destroy_pixel_hash(HashTable *hash)
+ {
+ PixelHashData *d=(PixelHashData *)hashtable_get_user_data(hash);
+ if (d) free(d);
+@@ -237,17 +223,15 @@ compute_box_volume(BoxNode *b)
+ }
+
+ static void
+-hash_to_list(HashTable h, const void *key, const void *val, void *u)
++hash_to_list(const HashTable *h, const Pixel pixel, const uint32_t count, void *u)
+ {
+ PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
+ PixelList **pl=(PixelList **)u;
+ PixelList *p;
+- Pixel *pixel=(Pixel *)&key;
+ int i;
+ Pixel q;
+- int count=(unsigned long) val;
+
+- PIXEL_SCALE(pixel,&q,d->scale);
++ PIXEL_SCALE(&pixel,&q,d->scale);
+
+ p=malloc(sizeof(PixelList));
+ if (!p) return;
+@@ -327,7 +311,7 @@ test_sorted(PixelList *pl[3])
+ #endif
+
+ static int
+-box_heap_cmp(const Heap h, const void *A, const void *B)
++box_heap_cmp(const Heap *h, const void *A, const void *B)
+ {
+ BoxNode *a=(BoxNode *)A;
+ BoxNode *b=(BoxNode *)B;
+@@ -341,11 +325,11 @@ splitlists(PixelList *h[3],
+ PixelList *t[3],
+ PixelList *nh[2][3],
+ PixelList *nt[2][3],
+- unsigned long nCount[2],
++ uint32_t nCount[2],
+ int axis,
+- unsigned long pixelCount)
++ uint32_t pixelCount)
+ {
+- unsigned long left;
++ uint32_t left;
+
+ PixelList *l,*r,*c,*n;
+ int i;
+@@ -476,7 +460,7 @@ split(BoxNode *node)
+ int i;
+ PixelList *heads[2][3];
+ PixelList *tails[2][3];
+- unsigned long newCounts[2];
++ uint32_t newCounts[2];
+ BoxNode *left,*right;
+
+ rh=node->head[0]->p.c.r;
+@@ -618,13 +602,13 @@ split(BoxNode *node)
+
+ static BoxNode *
+ median_cut(PixelList *hl[3],
+- unsigned long imPixelCount,
++ uint32_t imPixelCount,
+ int nPixels)
+ {
+ PixelList *tl[3];
+ int i;
+ BoxNode *root;
+- Heap h;
++ Heap* h;
+ BoxNode *thisNode;
+
+ h=ImagingQuantHeapNew(box_heap_cmp);
+@@ -701,7 +685,7 @@ checkContained(BoxNode *n,Pixel *pp)
+ #endif
+
+ static int
+-annotate_hash_table(BoxNode *n,HashTable h,unsigned long *box)
++annotate_hash_table(BoxNode *n,HashTable *h,uint32_t *box)
+ {
+ PixelList *p;
+ PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
+@@ -717,7 +701,7 @@ annotate_hash_table(BoxNode *n,HashTable h,unsigned long *box)
+ }
+ for (p=n->head[0];p;p=p->next[0]) {
+ PIXEL_UNSCALE(&(p->p),&q,d->scale);
+- if (!hashtable_insert(h,(void *)q.v,(void *)*box)) {
++ if (!hashtable_insert(h,q,*box)) {
+ #ifndef NO_OUTPUT
+ printf ("hashtable insert failed\n");
+ #endif
+@@ -731,20 +715,20 @@ annotate_hash_table(BoxNode *n,HashTable h,unsigned long *box)
+ static int
+ _sort_ulong_ptr_keys(const void *a, const void *b)
+ {
+- unsigned long A=**(unsigned long **)a;
+- unsigned long B=**(unsigned long **)b;
++ uint32_t A=**(uint32_t **)a;
++ uint32_t B=**(uint32_t **)b;
+ return (A==B)?0:((A<B)?-1:+1);
+ }
+
+ static int
+-resort_distance_tables(unsigned long *avgDist,
+- unsigned long **avgDistSortKey,
++resort_distance_tables(uint32_t *avgDist,
++ uint32_t **avgDistSortKey,
+ Pixel *p,
+- unsigned long nEntries)
++ uint32_t nEntries)
+ {
+- unsigned long i,j,k;
+- unsigned long **skRow;
+- unsigned long *skElt;
++ uint32_t i,j,k;
++ uint32_t **skRow;
++ uint32_t *skElt;
+
+ for (i=0;i<nEntries;i++) {
+ avgDist[i*nEntries+i]=0;
+@@ -767,12 +751,12 @@ resort_distance_tables(unsigned long *avgDist,
+ }
+
+ static int
+-build_distance_tables(unsigned long *avgDist,
+- unsigned long **avgDistSortKey,
++build_distance_tables(uint32_t *avgDist,
++ uint32_t **avgDistSortKey,
+ Pixel *p,
+- unsigned long nEntries)
++ uint32_t nEntries)
+ {
+- unsigned long i,j;
++ uint32_t i,j;
+
+ for (i=0;i<nEntries;i++) {
+ avgDist[i*nEntries+i]=0;
+@@ -787,7 +771,7 @@ build_distance_tables(unsigned long *avgDist,
+ for (i=0;i<nEntries;i++) {
+ qsort(avgDistSortKey+i*nEntries,
+ nEntries,
+- sizeof(unsigned long *),
++ sizeof(uint32_t *),
+ _sort_ulong_ptr_keys);
+ }
+ return 1;
+@@ -795,23 +779,23 @@ build_distance_tables(unsigned long *avgDist,
+
+ static int
+ map_image_pixels(Pixel *pixelData,
+- unsigned long nPixels,
++ uint32_t nPixels,
+ Pixel *paletteData,
+- unsigned long nPaletteEntries,
+- unsigned long *avgDist,
+- unsigned long **avgDistSortKey,
+- unsigned long *pixelArray)
++ uint32_t nPaletteEntries,
++ uint32_t *avgDist,
++ uint32_t **avgDistSortKey,
++ uint32_t *pixelArray)
+ {
+- unsigned long *aD,**aDSK;
+- unsigned long idx;
+- unsigned long i,j;
+- unsigned long bestdist,bestmatch,dist;
+- unsigned long initialdist;
+- HashTable h2;
++ uint32_t *aD,**aDSK;
++ uint32_t idx;
++ uint32_t i,j;
++ uint32_t bestdist,bestmatch,dist;
++ uint32_t initialdist;
++ HashTable *h2;
+
+ h2=hashtable_new(unshifted_pixel_hash,unshifted_pixel_cmp);
+ for (i=0;i<nPixels;i++) {
+- if (!hashtable_lookup(h2,(void *)pixelData[i].v,(void **)&bestmatch)) {
++ if (!hashtable_lookup(h2,pixelData[i],&bestmatch)) {
+ bestmatch=0;
+ initialdist=_DISTSQR(paletteData+bestmatch,pixelData+i);
+ bestdist=initialdist;
+@@ -830,7 +814,7 @@ map_image_pixels(Pixel *pixelData,
+ break;
+ }
+ }
+- hashtable_insert(h2,(void *)pixelData[i].v,(void *)bestmatch);
++ hashtable_insert(h2,pixelData[i],bestmatch);
+ }
+ pixelArray[i]=bestmatch;
+ }
+@@ -841,26 +825,26 @@ map_image_pixels(Pixel *pixelData,
+ static int
+ map_image_pixels_from_quantized_pixels(
+ Pixel *pixelData,
+- unsigned long nPixels,
++ uint32_t nPixels,
+ Pixel *paletteData,
+- unsigned long nPaletteEntries,
+- unsigned long *avgDist,
+- unsigned long **avgDistSortKey,
+- unsigned long *pixelArray,
+- unsigned long *avg[3],
+- unsigned long *count)
++ uint32_t nPaletteEntries,
++ uint32_t *avgDist,
++ uint32_t **avgDistSortKey,
++ uint32_t *pixelArray,
++ uint32_t *avg[3],
++ uint32_t *count)
+ {
+- unsigned long *aD,**aDSK;
+- unsigned long idx;
+- unsigned long i,j;
+- unsigned long bestdist,bestmatch,dist;
+- unsigned long initialdist;
+- HashTable h2;
++ uint32_t *aD,**aDSK;
++ uint32_t idx;
++ uint32_t i,j;
++ uint32_t bestdist,bestmatch,dist;
++ uint32_t initialdist;
++ HashTable *h2;
+ int changes=0;
+
+ h2=hashtable_new(unshifted_pixel_hash,unshifted_pixel_cmp);
+ for (i=0;i<nPixels;i++) {
+- if (!hashtable_lookup(h2,(void *)pixelData[i].v,(void **)&bestmatch)) {
++ if (!hashtable_lookup(h2,pixelData[i],&bestmatch)) {
+ bestmatch=pixelArray[i];
+ initialdist=_DISTSQR(paletteData+bestmatch,pixelData+i);
+ bestdist=initialdist;
+@@ -879,7 +863,7 @@ map_image_pixels_from_quantized_pixels(
+ break;
+ }
+ }
+- hashtable_insert(h2,(void *)pixelData[i].v,(void *)bestmatch);
++ hashtable_insert(h2,pixelData[i],bestmatch);
+ }
+ if (pixelArray[i]!=bestmatch) {
+ changes++;
+@@ -901,29 +885,29 @@ map_image_pixels_from_quantized_pixels(
+ static int
+ map_image_pixels_from_median_box(
+ Pixel *pixelData,
+- unsigned long nPixels,
++ uint32_t nPixels,
+ Pixel *paletteData,
+- unsigned long nPaletteEntries,
++ uint32_t nPaletteEntries,
+ HashTable *medianBoxHash,
+- unsigned long *avgDist,
+- unsigned long **avgDistSortKey,
+- unsigned long *pixelArray)
++ uint32_t *avgDist,
++ uint32_t **avgDistSortKey,
++ uint32_t *pixelArray)
+ {
+- unsigned long *aD,**aDSK;
+- unsigned long idx;
+- unsigned long i,j;
+- unsigned long bestdist,bestmatch,dist;
+- unsigned long initialdist;
+- HashTable h2;
+- unsigned long pixelVal;
++ uint32_t *aD,**aDSK;
++ uint32_t idx;
++ uint32_t i,j;
++ uint32_t bestdist,bestmatch,dist;
++ uint32_t initialdist;
++ HashTable *h2;
++ uint32_t pixelVal;
+
+ h2=hashtable_new(unshifted_pixel_hash,unshifted_pixel_cmp);
+ for (i=0;i<nPixels;i++) {
+- if (hashtable_lookup(h2,(void *)pixelData[i].v,(void **)&pixelVal)) {
++ if (hashtable_lookup(h2,pixelData[i],&pixelVal)) {
+ pixelArray[i]=pixelVal;
+ continue;
+ }
+- if (!hashtable_lookup(medianBoxHash,(void *)pixelData[i].v,(void **)&pixelVal)) {
++ if (!hashtable_lookup(medianBoxHash,pixelData[i],&pixelVal)) {
+ #ifndef NO_OUTPUT
+ printf ("pixel lookup failed\n");
+ #endif
+@@ -948,7 +932,7 @@ map_image_pixels_from_median_box(
+ }
+ }
+ pixelArray[i]=bestmatch;
+- hashtable_insert(h2,(void *)pixelData[i].v,(void *)bestmatch);
++ hashtable_insert(h2,pixelData[i],bestmatch);
+ }
+ hashtable_free(h2);
+ return 1;
+@@ -957,27 +941,27 @@ map_image_pixels_from_median_box(
+ static int
+ compute_palette_from_median_cut(
+ Pixel *pixelData,
+- unsigned long nPixels,
+- HashTable medianBoxHash,
++ uint32_t nPixels,
++ HashTable *medianBoxHash,
+ Pixel **palette,
+- unsigned long nPaletteEntries)
++ uint32_t nPaletteEntries)
+ {
+- unsigned long i;
+- unsigned long paletteEntry;
++ uint32_t i;
++ uint32_t paletteEntry;
+ Pixel *p;
+- unsigned long *avg[3];
+- unsigned long *count;
++ uint32_t *avg[3];
++ uint32_t *count;
+
+ *palette=NULL;
+- if (!(count=malloc(sizeof(unsigned long)*nPaletteEntries))) {
++ if (!(count=malloc(sizeof(uint32_t)*nPaletteEntries))) {
+ return 0;
+ }
+- memset(count,0,sizeof(unsigned long)*nPaletteEntries);
++ memset(count,0,sizeof(uint32_t)*nPaletteEntries);
+ for(i=0;i<3;i++) {
+ avg[i]=NULL;
+ }
+ for(i=0;i<3;i++) {
+- if (!(avg[i]=malloc(sizeof(unsigned long)*nPaletteEntries))) {
++ if (!(avg[i]=malloc(sizeof(uint32_t)*nPaletteEntries))) {
+ for(i=0;i<3;i++) {
+ if (avg[i]) free (avg[i]);
+ }
+@@ -986,7 +970,7 @@ compute_palette_from_median_cut(
+ }
+ }
+ for(i=0;i<3;i++) {
+- memset(avg[i],0,sizeof(unsigned long)*nPaletteEntries);
++ memset(avg[i],0,sizeof(uint32_t)*nPaletteEntries);
+ }
+ for (i=0;i<nPixels;i++) {
+ #ifdef TEST_SPLIT_INTEGRITY
+@@ -998,7 +982,7 @@ compute_palette_from_median_cut(
+ return 0;
+ }
+ #endif
+- if (!hashtable_lookup(medianBoxHash,(void *)pixelData[i].v,(void **)&paletteEntry)) {
++ if (!hashtable_lookup(medianBoxHash,pixelData[i],&paletteEntry)) {
+ #ifndef NO_OUTPUT
+ printf ("pixel lookup failed\n");
+ #endif
+@@ -1039,11 +1023,11 @@ compute_palette_from_median_cut(
+ static int
+ recompute_palette_from_averages(
+ Pixel *palette,
+- unsigned long nPaletteEntries,
+- unsigned long *avg[3],
+- unsigned long *count)
++ uint32_t nPaletteEntries,
++ uint32_t *avg[3],
++ uint32_t *count)
+ {
+- unsigned long i;
++ uint32_t i;
+
+ for (i=0;i<nPaletteEntries;i++) {
+ palette[i].c.r=(int)(.5+(double)avg[0][i]/(double)count[i]);
+@@ -1056,18 +1040,18 @@ recompute_palette_from_averages(
+ static int
+ compute_palette_from_quantized_pixels(
+ Pixel *pixelData,
+- unsigned long nPixels,
++ uint32_t nPixels,
+ Pixel *palette,
+- unsigned long nPaletteEntries,
+- unsigned long *avg[3],
+- unsigned long *count,
+- unsigned long *qp)
++ uint32_t nPaletteEntries,
++ uint32_t *avg[3],
++ uint32_t *count,
++ uint32_t *qp)
+ {
+- unsigned long i;
++ uint32_t i;
+
+- memset(count,0,sizeof(unsigned long)*nPaletteEntries);
++ memset(count,0,sizeof(uint32_t)*nPaletteEntries);
+ for(i=0;i<3;i++) {
+- memset(avg[i],0,sizeof(unsigned long)*nPaletteEntries);
++ memset(avg[i],0,sizeof(uint32_t)*nPaletteEntries);
+ }
+ for (i=0;i<nPixels;i++) {
+ if (qp[i]>=nPaletteEntries) {
+@@ -1091,35 +1075,35 @@ compute_palette_from_quantized_pixels(
+
+ static int
+ k_means(Pixel *pixelData,
+- unsigned long nPixels,
++ uint32_t nPixels,
+ Pixel *paletteData,
+- unsigned long nPaletteEntries,
+- unsigned long *qp,
++ uint32_t nPaletteEntries,
++ uint32_t *qp,
+ int threshold)
+ {
+- unsigned long *avg[3];
+- unsigned long *count;
+- unsigned long i;
+- unsigned long *avgDist;
+- unsigned long **avgDistSortKey;
++ uint32_t *avg[3];
++ uint32_t *count;
++ uint32_t i;
++ uint32_t *avgDist;
++ uint32_t **avgDistSortKey;
+ int changes;
+ int built=0;
+
+- if (!(count=malloc(sizeof(unsigned long)*nPaletteEntries))) {
++ if (!(count=malloc(sizeof(uint32_t)*nPaletteEntries))) {
+ return 0;
+ }
+ for(i=0;i<3;i++) {
+ avg[i]=NULL;
+ }
+ for(i=0;i<3;i++) {
+- if (!(avg[i]=malloc(sizeof(unsigned long)*nPaletteEntries))) {
++ if (!(avg[i]=malloc(sizeof(uint32_t)*nPaletteEntries))) {
+ goto error_1;
+ }
+ }
+- avgDist=malloc(sizeof(unsigned long)*nPaletteEntries*nPaletteEntries);
++ avgDist=malloc(sizeof(uint32_t)*nPaletteEntries*nPaletteEntries);
+ if (!avgDist) { goto error_1; }
+
+- avgDistSortKey=malloc(sizeof(unsigned long *)*nPaletteEntries*nPaletteEntries);
++ avgDistSortKey=malloc(sizeof(uint32_t *)*nPaletteEntries*nPaletteEntries);
+ if (!avgDistSortKey) { goto error_2; }
+
+ #ifndef NO_OUTPUT
+@@ -1172,26 +1156,26 @@ error_1:
+
+ int
+ quantize(Pixel *pixelData,
+- unsigned long nPixels,
+- unsigned long nQuantPixels,
++ uint32_t nPixels,
++ uint32_t nQuantPixels,
+ Pixel **palette,
+- unsigned long *paletteLength,
+- unsigned long **quantizedPixels,
++ uint32_t *paletteLength,
++ uint32_t **quantizedPixels,
+ int kmeans)
+ {
+ PixelList *hl[3];
+- HashTable h;
++ HashTable *h;
+ BoxNode *root;
+- unsigned long i;
+- unsigned long *qp;
+- unsigned long nPaletteEntries;
++ uint32_t i;
++ uint32_t *qp;
++ uint32_t nPaletteEntries;
+
+- unsigned long *avgDist;
+- unsigned long **avgDistSortKey;
++ uint32_t *avgDist;
++ uint32_t **avgDistSortKey;
+ Pixel *p;
+
+ #ifndef NO_OUTPUT
+- unsigned long timer,timer2;
++ uint32_t timer,timer2;
+ #endif
+
+ #ifndef NO_OUTPUT
+@@ -1266,13 +1250,13 @@ quantize(Pixel *pixelData,
+ free_box_tree(root);
+ root=NULL;
+
+- qp=malloc(sizeof(unsigned long)*nPixels);
++ qp=malloc(sizeof(uint32_t)*nPixels);
+ if (!qp) { goto error_4; }
+
+- avgDist=malloc(sizeof(unsigned long)*nPaletteEntries*nPaletteEntries);
++ avgDist=malloc(sizeof(uint32_t)*nPaletteEntries*nPaletteEntries);
+ if (!avgDist) { goto error_5; }
+
+- avgDistSortKey=malloc(sizeof(unsigned long *)*nPaletteEntries*nPaletteEntries);
++ avgDistSortKey=malloc(sizeof(uint32_t *)*nPaletteEntries*nPaletteEntries);
+ if (!avgDistSortKey) { goto error_6; }
+
+ if (!build_distance_tables(avgDist,avgDistSortKey,p,nPaletteEntries)) {
+@@ -1286,12 +1270,12 @@ quantize(Pixel *pixelData,
+ #ifdef TEST_NEAREST_NEIGHBOUR
+ #include <math.h>
+ {
+- unsigned long bestmatch,bestdist,dist;
+- HashTable h2;
++ uint32_t bestmatch,bestdist,dist;
++ HashTable *h2;
+ printf ("nearest neighbour search (full search)..."); fflush(stdout); timer=clock();
+ h2=hashtable_new(unshifted_pixel_hash,unshifted_pixel_cmp);
+ for (i=0;i<nPixels;i++) {
+- if (hashtable_lookup(h2,(void *)pixelData[i].v,(void **)&paletteEntry)) {
++ if (hashtable_lookup(h2,pixelData[i],&paletteEntry)) {
+ bestmatch=paletteEntry;
+ } else {
+ bestmatch=0;
+@@ -1312,7 +1296,7 @@ quantize(Pixel *pixelData,
+ bestmatch=j;
+ }
+ }
+- hashtable_insert(h2,(void *)pixelData[i].v,(void *)bestmatch);
++ hashtable_insert(h2,pixelData[i],bestmatch);
+ }
+ if (qp[i]!=bestmatch ) {
+ printf ("discrepancy in matching algorithms pixel %d [%d %d] %f %f\n",
+@@ -1375,53 +1359,52 @@ error_0:
+ typedef struct {
+ Pixel new;
+ Pixel furthest;
+- unsigned long furthestDistance;
++ uint32_t furthestDistance;
+ int secondPixel;
+ } DistanceData;
+
+ static void
+-compute_distances(const HashTable h, const void *key, void **val, void *u)
++compute_distances(const HashTable *h, const Pixel pixel, uint32_t *dist, void *u)
+ {
+ DistanceData *data=(DistanceData *)u;
+- Pixel *pixel=(Pixel *)&key;
+- unsigned long oldDist=*(unsigned long *)val;
+- unsigned long newDist;
+- newDist=_DISTSQR(&(data->new),pixel);
++ uint32_t oldDist=*dist;
++ uint32_t newDist;
++ newDist=_DISTSQR(&(data->new),&pixel);
+ if (data->secondPixel || newDist<oldDist) {
+- *(unsigned long *)val=newDist;
++ *dist=newDist;
+ oldDist=newDist;
+ }
+ if (oldDist>data->furthestDistance) {
+ data->furthestDistance=oldDist;
+- data->furthest.v=pixel->v;
++ data->furthest.v=pixel.v;
+ }
+ }
+
+ int
+ quantize2(Pixel *pixelData,
+- unsigned long nPixels,
+- unsigned long nQuantPixels,
++ uint32_t nPixels,
++ uint32_t nQuantPixels,
+ Pixel **palette,
+- unsigned long *paletteLength,
+- unsigned long **quantizedPixels,
++ uint32_t *paletteLength,
++ uint32_t **quantizedPixels,
+ int kmeans)
+ {
+- HashTable h;
+- unsigned long i;
+- unsigned long mean[3];
++ HashTable *h;
++ uint32_t i;
++ uint32_t mean[3];
+ Pixel *p;
+ DistanceData data;
+
+- unsigned long *qp;
+- unsigned long *avgDist;
+- unsigned long **avgDistSortKey;
++ uint32_t *qp;
++ uint32_t *avgDist;
++ uint32_t **avgDistSortKey;
+
+ p=malloc(sizeof(Pixel)*nQuantPixels);
+ if (!p) return 0;
+ mean[0]=mean[1]=mean[2]=0;
+ h=hashtable_new(unshifted_pixel_hash,unshifted_pixel_cmp);
+ for (i=0;i<nPixels;i++) {
+- hashtable_insert(h,(void *)pixelData[i].v,(void *)0xffffffff);
++ hashtable_insert(h,pixelData[i],0xffffffff);
+ mean[0]+=pixelData[i].c.r;
+ mean[1]+=pixelData[i].c.g;
+ mean[2]+=pixelData[i].c.b;
+@@ -1438,13 +1421,13 @@ quantize2(Pixel *pixelData,
+ }
+ hashtable_free(h);
+
+- qp=malloc(sizeof(unsigned long)*nPixels);
++ qp=malloc(sizeof(uint32_t)*nPixels);
+ if (!qp) { goto error_1; }
+
+- avgDist=malloc(sizeof(unsigned long)*nQuantPixels*nQuantPixels);
++ avgDist=malloc(sizeof(uint32_t)*nQuantPixels*nQuantPixels);
+ if (!avgDist) { goto error_2; }
+
+- avgDistSortKey=malloc(sizeof(unsigned long *)*nQuantPixels*nQuantPixels);
++ avgDistSortKey=malloc(sizeof(uint32_t *)*nQuantPixels*nQuantPixels);
+ if (!avgDistSortKey) { goto error_3; }
+
+ if (!build_distance_tables(avgDist,avgDistSortKey,p,nQuantPixels)) {
+@@ -1482,9 +1465,9 @@ ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
+ UINT8* pp;
+ Pixel* p;
+ Pixel* palette;
+- unsigned long paletteLength;
++ uint32_t paletteLength;
+ int result;
+- unsigned long* newData;
++ uint32_t* newData;
+ Imaging imOut;
+ int withAlpha = 0;
+ ImagingSectionCookie cookie;
+diff --git a/libImaging/Quant.h b/libImaging/Quant.h
+deleted file mode 100644
+index 0de485a..0000000
+--- a/libImaging/Quant.h
++++ /dev/null
+@@ -1,40 +0,0 @@
+-/*
+- * The Python Imaging Library
+- * $Id$
+- *
+- * image quantizer
+- *
+- * Written by Toby J Sargeant <tjs at longford.cs.monash.edu.au>.
+- *
+- * See the README file for information on usage and redistribution.
+- */
+-
+-#ifndef __QUANT_H__
+-#define __QUANT_H__
+-
+-typedef union {
+- struct {
+- unsigned char r,g,b,a;
+- } c;
+- struct {
+- unsigned char v[4];
+- } a;
+- unsigned long v;
+-} Pixel;
+-
+-int quantize(Pixel *,
+- unsigned long,
+- unsigned long,
+- Pixel **,
+- unsigned long *,
+- unsigned long **,
+- int);
+-
+-int quantize2(Pixel *,
+- unsigned long,
+- unsigned long,
+- Pixel **,
+- unsigned long *,
+- unsigned long **,
+- int);
+-#endif
+diff --git a/libImaging/QuantDefines.h b/libImaging/QuantDefines.h
+deleted file mode 100644
+index 5b08010..0000000
+--- a/libImaging/QuantDefines.h
++++ /dev/null
+@@ -1,25 +0,0 @@
+-/*
+- * The Python Imaging Library
+- * $Id$
+- *
+- * image quantizer
+- *
+- * Written by Toby J Sargeant <tjs at longford.cs.monash.edu.au>.
+- *
+- * See the README file for information on usage and redistribution.
+- */
+-
+-#ifndef __DEFINES_H__
+-#define __DEFINES_H__
+-
+-#if 0
+-
+-void *newMalloc(size_t,const char *,const char *,int);
+-void newFree(void *,const char *,const char *,int);
+-void print_malloc_stats();
+-#define malloc(x) newMalloc(x,__FILE__,__FUNCTION__,__LINE__)
+-#define free(x) newFree(x,__FILE__,__FUNCTION__,__LINE__)
+-
+-#endif
+-
+-#endif
+diff --git a/libImaging/QuantHash.c b/libImaging/QuantHash.c
+index e643840..58d8813 100644
+--- a/libImaging/QuantHash.c
++++ b/libImaging/QuantHash.c
+@@ -22,35 +22,35 @@
+ #include <math.h>
+
+ #include "QuantHash.h"
+-#include "QuantDefines.h"
+
+-typedef struct _IntHashNode {
+- struct _IntHashNode *next;
+- void *key,*value;
+-} IntHashNode;
++typedef struct _HashNode {
++ struct _HashNode *next;
++ HashKey_t key;
++ HashVal_t value;
++} HashNode;
+
+-typedef struct _IntHashTable {
+- IntHashNode **table;
+- unsigned long length;
+- unsigned long count;
++typedef struct _HashTable {
++ HashNode **table;
++ uint32_t length;
++ uint32_t count;
+ HashFunc hashFunc;
+ HashCmpFunc cmpFunc;
+- DestroyFunc keyDestroyFunc;
+- DestroyFunc valDestroyFunc;
++ KeyDestroyFunc keyDestroyFunc;
++ ValDestroyFunc valDestroyFunc;
+ void *userData;
+-} IntHashTable;
++} HashTable;
+
+ #define MIN_LENGTH 11
+ #define RESIZE_FACTOR 3
+
+-static int _hashtable_insert_node(IntHashTable *,IntHashNode *,int,int,CollisionFunc);
++static int _hashtable_insert_node(HashTable *,HashNode *,int,int,CollisionFunc);
+ #if 0
+-static int _hashtable_test(IntHashTable *);
++static int _hashtable_test(HashTable *);
+ #endif
+
+-HashTable hashtable_new(HashFunc hf,HashCmpFunc cf) {
+- IntHashTable *h;
+- h=malloc(sizeof(IntHashTable));
++HashTable *hashtable_new(HashFunc hf,HashCmpFunc cf) {
++ HashTable *h;
++ h=malloc(sizeof(HashTable));
+ if (!h) { return NULL; }
+ h->hashFunc=hf;
+ h->cmpFunc=cf;
+@@ -59,25 +59,24 @@ HashTable hashtable_new(HashFunc hf,HashCmpFunc cf) {
+ h->length=MIN_LENGTH;
+ h->count=0;
+ h->userData=NULL;
+- h->table=malloc(sizeof(IntHashNode *)*h->length);
++ h->table=malloc(sizeof(HashNode *)*h->length);
+ if (!h->table) { free(h); return NULL; }
+- memset (h->table,0,sizeof(IntHashNode *)*h->length);
+- return (HashTable)h;
++ memset (h->table,0,sizeof(HashNode *)*h->length);
++ return h;
+ }
+
+-static void _hashtable_destroy(HashTable H,const void *key,const void *val,void *u) {
+- IntHashTable *h=(IntHashTable *)H;
+- if (h->keyDestroyFunc&&key) {
+- h->keyDestroyFunc((HashTable)h,(void *)key);
++static void _hashtable_destroy(const HashTable *h,const HashKey_t key,const HashVal_t val,void *u) {
++ if (h->keyDestroyFunc) {
++ h->keyDestroyFunc(h,key);
+ }
+- if (h->valDestroyFunc&&val) {
+- h->valDestroyFunc((HashTable)h,(void *)val);
++ if (h->valDestroyFunc) {
++ h->valDestroyFunc(h,val);
+ }
+ }
+
+-static unsigned long _findPrime(unsigned long start,int dir) {
++static uint32_t _findPrime(uint32_t start,int dir) {
+ static int unit[]={0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0};
+- unsigned long t;
++ uint32_t t;
+ while (start>1) {
+ if (!unit[start&0x0f]) {
+ start+=dir;
+@@ -94,22 +93,20 @@ static unsigned long _findPrime(unsigned long start,int dir) {
+ return start;
+ }
+
+-static void _hashtable_rehash(IntHashTable *h,
+- CollisionFunc cf,
+- unsigned long newSize) {
+- IntHashNode **oldTable=h->table;
+- unsigned long i;
+- IntHashNode *n,*nn;
+- unsigned long oldSize;
++static void _hashtable_rehash(HashTable *h,CollisionFunc cf,uint32_t newSize) {
++ HashNode **oldTable=h->table;
++ uint32_t i;
++ HashNode *n,*nn;
++ uint32_t oldSize;
+ oldSize=h->length;
+- h->table=malloc(sizeof(IntHashNode *)*newSize);
++ h->table=malloc(sizeof(HashNode *)*newSize);
+ if (!h->table) {
+ h->table=oldTable;
+ return;
+ }
+ h->length=newSize;
+ h->count=0;
+- memset (h->table,0,sizeof(IntHashNode *)*h->length);
++ memset (h->table,0,sizeof(HashNode *)*h->length);
+ for (i=0;i<oldSize;i++) {
+ for (n=oldTable[i];n;n=nn) {
+ nn=n->next;
+@@ -119,9 +116,9 @@ static void _hashtable_rehash(IntHashTable *h,
+ free(oldTable);
+ }
+
+-static void _hashtable_resize(IntHashTable *h) {
+- unsigned long newSize;
+- unsigned long oldSize;
++static void _hashtable_resize(HashTable *h) {
++ uint32_t newSize;
++ uint32_t oldSize;
+ oldSize=h->length;
+ newSize=oldSize;
+ if (h->count*RESIZE_FACTOR<h->length) {
+@@ -136,13 +133,13 @@ static void _hashtable_resize(IntHashTable *h) {
+ }
+
+ #if 0
+-static int _hashtable_test(IntHashTable *h) {
+- unsigned long i;
++static int _hashtable_test(HashTable *h) {
++ uint32_t i;
+ int j;
+- IntHashNode *n;
++ HashNode *n;
+ for (i=0;i<h->length;i++) {
+ for (n=h->table[i];n&&n->next;n=n->next) {
+- j=h->cmpFunc((HashTable)h,n->key,n->next->key);
++ j=h->cmpFunc(h,n->key,n->next->key);
+ printf ("%c",j?(j<0?'-':'+'):'=');
+ }
+ printf ("\n");
+@@ -151,26 +148,26 @@ static int _hashtable_test(IntHashTable *h) {
+ }
+ #endif
+
+-static int _hashtable_insert_node(IntHashTable *h,IntHashNode *node,int resize,int update,CollisionFunc cf) {
+- unsigned long hash=h->hashFunc((HashTable)h,node->key)%h->length;
+- IntHashNode **n,*nv;
++static int _hashtable_insert_node(HashTable *h,HashNode *node,int resize,int update,CollisionFunc cf) {
++ uint32_t hash=h->hashFunc(h,node->key)%h->length;
++ HashNode **n,*nv;
+ int i;
+
+ for (n=&(h->table[hash]);*n;n=&((*n)->next)) {
+ nv=*n;
+- i=h->cmpFunc((HashTable)h,nv->key,node->key);
++ i=h->cmpFunc(h,nv->key,node->key);
+ if (!i) {
+ if (cf) {
+ nv->key=node->key;
+- cf((HashTable)h,&(nv->key),&(nv->value),node->key,node->value);
++ cf(h,&(nv->key),&(nv->value),node->key,node->value);
+ free(node);
+ return 1;
+ } else {
+ if (h->valDestroyFunc) {
+- h->valDestroyFunc((HashTable)h,nv->value);
++ h->valDestroyFunc(h,nv->value);
+ }
+ if (h->keyDestroyFunc) {
+- h->keyDestroyFunc((HashTable)h,nv->key);
++ h->keyDestroyFunc(h,nv->key);
+ }
+ nv->key=node->key;
+ nv->value=node->value;
+@@ -192,17 +189,17 @@ static int _hashtable_insert_node(IntHashTable *h,IntHashNode *node,int resize,i
+ }
+ }
+
+-static int _hashtable_insert(IntHashTable *h,void *key,void *val,int resize,int update) {
+- IntHashNode **n,*nv;
+- IntHashNode *t;
++static int _hashtable_insert(HashTable *h,HashKey_t key,HashVal_t val,int resize,int update) {
++ HashNode **n,*nv;
++ HashNode *t;
+ int i;
+- unsigned long hash=h->hashFunc((HashTable)h,key)%h->length;
++ uint32_t hash=h->hashFunc(h,key)%h->length;
+
+ for (n=&(h->table[hash]);*n;n=&((*n)->next)) {
+ nv=*n;
+- i=h->cmpFunc((HashTable)h,nv->key,key);
++ i=h->cmpFunc(h,nv->key,key);
+ if (!i) {
+- if (h->valDestroyFunc) { h->valDestroyFunc((HashTable)h,nv->value); }
++ if (h->valDestroyFunc) { h->valDestroyFunc(h,nv->value); }
+ nv->value=val;
+ return 1;
+ } else if (i>0) {
+@@ -210,7 +207,7 @@ static int _hashtable_insert(IntHashTable *h,void *key,void *val,int resize,int
+ }
+ }
+ if (!update) {
+- t=malloc(sizeof(IntHashNode));
++ t=malloc(sizeof(HashNode));
+ if (!t) return 0;
+ t->next=*n;
+ *n=t;
+@@ -224,15 +221,15 @@ static int _hashtable_insert(IntHashTable *h,void *key,void *val,int resize,int
+ }
+ }
+
+-static int _hashtable_lookup_or_insert(IntHashTable *h,void *key,void **retVal,void *newVal,int resize) {
+- IntHashNode **n,*nv;
+- IntHashNode *t;
++static int _hashtable_lookup_or_insert(HashTable *h,HashKey_t key,HashVal_t *retVal,HashVal_t newVal,int resize) {
++ HashNode **n,*nv;
++ HashNode *t;
+ int i;
+- unsigned long hash=h->hashFunc((HashTable)h,key)%h->length;
++ uint32_t hash=h->hashFunc(h,key)%h->length;
+
+ for (n=&(h->table[hash]);*n;n=&((*n)->next)) {
+ nv=*n;
+- i=h->cmpFunc((HashTable)h,nv->key,key);
++ i=h->cmpFunc(h,nv->key,key);
+ if (!i) {
+ *retVal=nv->value;
+ return 1;
+@@ -240,7 +237,7 @@ static int _hashtable_lookup_or_insert(IntHashTable *h,void *key,void **retVal,v
+ break;
+ }
+ }
+- t=malloc(sizeof(IntHashNode));
++ t=malloc(sizeof(HashNode));
+ if (!t) return 0;
+ t->next=*n;
+ *n=t;
+@@ -252,26 +249,25 @@ static int _hashtable_lookup_or_insert(IntHashTable *h,void *key,void **retVal,v
+ return 1;
+ }
+
+-int hashtable_insert_or_update_computed(HashTable H,
+- void *key,
++int hashtable_insert_or_update_computed(HashTable *h,
++ HashKey_t key,
+ ComputeFunc newFunc,
+ ComputeFunc existsFunc) {
+- IntHashTable *h=(IntHashTable *)H;
+- IntHashNode **n,*nv;
+- IntHashNode *t;
++ HashNode **n,*nv;
++ HashNode *t;
+ int i;
+- unsigned long hash=h->hashFunc((HashTable)h,key)%h->length;
++ uint32_t hash=h->hashFunc(h,key)%h->length;
+
+ for (n=&(h->table[hash]);*n;n=&((*n)->next)) {
+ nv=*n;
+- i=h->cmpFunc((HashTable)h,nv->key,key);
++ i=h->cmpFunc(h,nv->key,key);
+ if (!i) {
+- void *old=nv->value;
++ HashVal_t old=nv->value;
+ if (existsFunc) {
+- existsFunc(H,nv->key,&(nv->value));
++ existsFunc(h,nv->key,&(nv->value));
+ if (nv->value!=old) {
+ if (h->valDestroyFunc) {
+- h->valDestroyFunc((HashTable)h,old);
++ h->valDestroyFunc(h,old);
+ }
+ }
+ } else {
+@@ -282,13 +278,13 @@ int hashtable_insert_or_update_computed(HashTable H,
+ break;
+ }
+ }
+- t=malloc(sizeof(IntHashNode));
++ t=malloc(sizeof(HashNode));
+ if (!t) return 0;
+ t->key=key;
+ t->next=*n;
+ *n=t;
+ if (newFunc) {
+- newFunc(H,t->key,&(t->value));
++ newFunc(h,t->key,&(t->value));
+ } else {
+ free(t);
+ return 0;
+@@ -298,52 +294,47 @@ int hashtable_insert_or_update_computed(HashTable H,
+ return 1;
+ }
+
+-int hashtable_update(HashTable H,void *key,void *val) {
+- IntHashTable *h=(IntHashTable *)H;
++int hashtable_update(HashTable *h,HashKey_t key,HashVal_t val) {
+ return _hashtable_insert(h,key,val,1,0);
+ }
+
+-int hashtable_insert(HashTable H,void *key,void *val) {
+- IntHashTable *h=(IntHashTable *)H;
++int hashtable_insert(HashTable *h,HashKey_t key,HashVal_t val) {
+ return _hashtable_insert(h,key,val,1,0);
+ }
+
+-void hashtable_foreach_update(HashTable H,IteratorUpdateFunc i,void *u) {
+- IntHashTable *h=(IntHashTable *)H;
+- IntHashNode *n;
+- unsigned long x;
++void hashtable_foreach_update(HashTable *h,IteratorUpdateFunc i,void *u) {
++ HashNode *n;
++ uint32_t x;
+
+ if (h->table) {
+ for (x=0;x<h->length;x++) {
+ for (n=h->table[x];n;n=n->next) {
+- i((HashTable)h,n->key,(void **)&(n->value),u);
++ i(h,n->key,&(n->value),u);
+ }
+ }
+ }
+ }
+
+-void hashtable_foreach(HashTable H,IteratorFunc i,void *u) {
+- IntHashTable *h=(IntHashTable *)H;
+- IntHashNode *n;
+- unsigned long x;
++void hashtable_foreach(HashTable *h,IteratorFunc i,void *u) {
++ HashNode *n;
++ uint32_t x;
+
+ if (h->table) {
+ for (x=0;x<h->length;x++) {
+ for (n=h->table[x];n;n=n->next) {
+- i((HashTable)h,n->key,n->value,u);
++ i(h,n->key,n->value,u);
+ }
+ }
+ }
+ }
+
+-void hashtable_free(HashTable H) {
+- IntHashTable *h=(IntHashTable *)H;
+- IntHashNode *n,*nn;
+- unsigned long i;
++void hashtable_free(HashTable *h) {
++ HashNode *n,*nn;
++ uint32_t i;
+
+ if (h->table) {
+ if (h->keyDestroyFunc || h->keyDestroyFunc) {
+- hashtable_foreach(H,_hashtable_destroy,NULL);
++ hashtable_foreach(h,_hashtable_destroy,NULL);
+ }
+ for (i=0;i<h->length;i++) {
+ for (n=h->table[i];n;n=nn) {
+@@ -356,31 +347,29 @@ void hashtable_free(HashTable H) {
+ free(h);
+ }
+
+-DestroyFunc hashtable_set_value_destroy_func(HashTable H,DestroyFunc d) {
+- IntHashTable *h=(IntHashTable *)H;
+- DestroyFunc r=h->valDestroyFunc;
++ValDestroyFunc hashtable_set_value_destroy_func(HashTable *h,ValDestroyFunc d) {
++ ValDestroyFunc r=h->valDestroyFunc;
+ h->valDestroyFunc=d;
+ return r;
+ }
+
+-DestroyFunc hashtable_set_key_destroy_func(HashTable H,DestroyFunc d) {
+- IntHashTable *h=(IntHashTable *)H;
+- DestroyFunc r=h->keyDestroyFunc;
++KeyDestroyFunc hashtable_set_key_destroy_func(HashTable *h,KeyDestroyFunc d) {
++ KeyDestroyFunc r=h->keyDestroyFunc;
+ h->keyDestroyFunc=d;
+ return r;
+ }
+
+-static int _hashtable_remove(IntHashTable *h,
+- const void *key,
+- void **keyRet,
+- void **valRet,
++static int _hashtable_remove(HashTable *h,
++ const HashKey_t key,
++ HashKey_t *keyRet,
++ HashVal_t *valRet,
+ int resize) {
+- unsigned long hash=h->hashFunc((HashTable)h,key)%h->length;
+- IntHashNode *n,*p;
++ uint32_t hash=h->hashFunc(h,key)%h->length;
++ HashNode *n,*p;
+ int i;
+
+ for (p=NULL,n=h->table[hash];n;p=n,n=n->next) {
+- i=h->cmpFunc((HashTable)h,n->key,key);
++ i=h->cmpFunc(h,n->key,key);
+ if (!i) {
+ if (p) p=n->next; else h->table[hash]=n->next;
+ *keyRet=n->key;
+@@ -395,17 +384,17 @@ static int _hashtable_remove(IntHashTable *h,
+ return 0;
+ }
+
+-static int _hashtable_delete(IntHashTable *h,const void *key,int resize) {
+- unsigned long hash=h->hashFunc((HashTable)h,key)%h->length;
+- IntHashNode *n,*p;
++static int _hashtable_delete(HashTable *h,const HashKey_t key,int resize) {
++ uint32_t hash=h->hashFunc(h,key)%h->length;
++ HashNode *n,*p;
+ int i;
+
+ for (p=NULL,n=h->table[hash];n;p=n,n=n->next) {
+- i=h->cmpFunc((HashTable)h,n->key,key);
++ i=h->cmpFunc(h,n->key,key);
+ if (!i) {
+ if (p) p=n->next; else h->table[hash]=n->next;
+- if (h->valDestroyFunc) { h->valDestroyFunc((HashTable)h,n->value); }
+- if (h->keyDestroyFunc) { h->keyDestroyFunc((HashTable)h,n->key); }
++ if (h->valDestroyFunc) { h->valDestroyFunc(h,n->value); }
++ if (h->keyDestroyFunc) { h->keyDestroyFunc(h,n->key); }
+ free(n);
+ h->count++;
+ return 1;
+@@ -416,39 +405,33 @@ static int _hashtable_delete(IntHashTable *h,const void *key,int resize) {
+ return 0;
+ }
+
+-int hashtable_remove(HashTable H,const void *key,void **keyRet,void **valRet) {
+- IntHashTable *h=(IntHashTable *)H;
++int hashtable_remove(HashTable *h,const HashKey_t key,HashKey_t *keyRet,HashVal_t *valRet) {
+ return _hashtable_remove(h,key,keyRet,valRet,1);
+ }
+
+-int hashtable_delete(HashTable H,const void *key) {
+- IntHashTable *h=(IntHashTable *)H;
++int hashtable_delete(HashTable *h,const HashKey_t key) {
+ return _hashtable_delete(h,key,1);
+ }
+
+-void hashtable_rehash_compute(HashTable H,CollisionFunc cf) {
+- IntHashTable *h=(IntHashTable *)H;
++void hashtable_rehash_compute(HashTable *h,CollisionFunc cf) {
+ _hashtable_rehash(h,cf,h->length);
+ }
+
+-void hashtable_rehash(HashTable H) {
+- IntHashTable *h=(IntHashTable *)H;
++void hashtable_rehash(HashTable *h) {
+ _hashtable_rehash(h,NULL,h->length);
+ }
+
+-int hashtable_lookup_or_insert(HashTable H,void *key,void **valp,void *val) {
+- IntHashTable *h=(IntHashTable *)H;
++int hashtable_lookup_or_insert(HashTable *h,HashKey_t key,HashVal_t *valp,HashVal_t val) {
+ return _hashtable_lookup_or_insert(h,key,valp,val,1);
+ }
+
+-int hashtable_lookup(const HashTable H,const void *key,void **valp) {
+- IntHashTable *h=(IntHashTable *)H;
+- unsigned long hash=h->hashFunc((HashTable)h,key)%h->length;
+- IntHashNode *n;
++int hashtable_lookup(const HashTable *h,const HashKey_t key,HashVal_t *valp) {
++ uint32_t hash=h->hashFunc(h,key)%h->length;
++ HashNode *n;
+ int i;
+
+ for (n=h->table[hash];n;n=n->next) {
+- i=h->cmpFunc((HashTable)h,n->key,key);
++ i=h->cmpFunc(h,n->key,key);
+ if (!i) {
+ *valp=n->value;
+ return 1;
+@@ -459,18 +442,15 @@ int hashtable_lookup(const HashTable H,const void *key,void **valp) {
+ return 0;
+ }
+
+-unsigned long hashtable_get_count(const HashTable H) {
+- IntHashTable *h=(IntHashTable *)H;
++uint32_t hashtable_get_count(const HashTable *h) {
+ return h->count;
+ }
+
+-void *hashtable_get_user_data(const HashTable H) {
+- IntHashTable *h=(IntHashTable *)H;
++void *hashtable_get_user_data(const HashTable *h) {
+ return h->userData;
+ }
+
+-void *hashtable_set_user_data(HashTable H,void *data) {
+- IntHashTable *h=(IntHashTable *)H;
++void *hashtable_set_user_data(HashTable *h,void *data) {
+ void *r=h->userData;
+ h->userData=data;
+ return r;
+diff --git a/libImaging/QuantHash.h b/libImaging/QuantHash.h
+index b98b56e..028b4af 100644
+--- a/libImaging/QuantHash.h
++++ b/libImaging/QuantHash.h
+@@ -9,28 +9,41 @@
+ * See the README file for information on usage and redistribution.
+ */
+
+-#ifndef __HASH_H__
+-#define __HASH_H__
++#ifndef __QUANTHASH_H__
++#define __QUANTHASH_H__
+
+ #include "QuantTypes.h"
+
+-HashTable hashtable_new(HashFunc,HashCmpFunc);
+-void hashtable_free(HashTable);
+-void hashtable_foreach(HashTable,IteratorFunc,void *);
+-void hashtable_foreach_update(HashTable,IteratorUpdateFunc,void *);
+-int hashtable_insert(HashTable,void *,void *);
+-int hashtable_update(HashTable,void *,void *);
+-int hashtable_lookup(const HashTable,const void *,void **);
+-int hashtable_lookup_or_insert(HashTable,void *,void **,void *);
+-int hashtable_insert_or_update_computed(HashTable,void *,ComputeFunc,ComputeFunc);
+-int hashtable_delete(HashTable,const void *);
+-int hashtable_remove(HashTable,const void *,void **,void **);
+-void *hashtable_set_user_data(HashTable,void *);
+-void *hashtable_get_user_data(const HashTable);
+-DestroyFunc hashtable_set_key_destroy_func(HashTable,DestroyFunc);
+-DestroyFunc hashtable_set_value_destroy_func(HashTable,DestroyFunc);
+-unsigned long hashtable_get_count(const HashTable);
+-void hashtable_rehash(HashTable);
+-void hashtable_rehash_compute(HashTable,CollisionFunc);
++typedef struct _HashTable HashTable;
++typedef Pixel HashKey_t;
++typedef uint32_t HashVal_t;
+
+-#endif
++typedef uint32_t (*HashFunc)(const HashTable *,const HashKey_t);
++typedef int (*HashCmpFunc)(const HashTable *,const HashKey_t,const HashKey_t);
++typedef void (*IteratorFunc)(const HashTable *,const HashKey_t,const HashVal_t,void *);
++typedef void (*IteratorUpdateFunc)(const HashTable *,const HashKey_t,HashVal_t *,void *);
++typedef void (*KeyDestroyFunc)(const HashTable *,HashKey_t);
++typedef void (*ValDestroyFunc)(const HashTable *,HashVal_t);
++typedef void (*ComputeFunc)(const HashTable *,const HashKey_t,HashVal_t *);
++typedef void (*CollisionFunc)(const HashTable *,HashKey_t *,HashVal_t *,HashKey_t,HashVal_t);
++
++HashTable * hashtable_new(HashFunc hf,HashCmpFunc cf);
++void hashtable_free(HashTable *h);
++void hashtable_foreach(HashTable *h,IteratorFunc i,void *u);
++void hashtable_foreach_update(HashTable *h,IteratorUpdateFunc i,void *u);
++int hashtable_insert(HashTable *h,HashKey_t key,HashVal_t val);
++int hashtable_update(HashTable *h,HashKey_t key,HashVal_t val);
++int hashtable_lookup(const HashTable *h,const HashKey_t key,HashVal_t *valp);
++int hashtable_lookup_or_insert(HashTable *h,HashKey_t key,HashVal_t *valp,HashVal_t val);
++int hashtable_insert_or_update_computed(HashTable *h,HashKey_t key,ComputeFunc newFunc,ComputeFunc existsFunc);
++int hashtable_delete(HashTable *h,const HashKey_t key);
++int hashtable_remove(HashTable *h,const HashKey_t key,HashKey_t *keyRet,HashVal_t *valRet);
++void *hashtable_set_user_data(HashTable *h,void *data);
++void *hashtable_get_user_data(const HashTable *h);
++KeyDestroyFunc hashtable_set_key_destroy_func(HashTable *,KeyDestroyFunc d);
++ValDestroyFunc hashtable_set_value_destroy_func(HashTable *,ValDestroyFunc d);
++uint32_t hashtable_get_count(const HashTable *h);
++void hashtable_rehash(HashTable *h);
++void hashtable_rehash_compute(HashTable *h,CollisionFunc cf);
++
++#endif // __QUANTHASH_H__
+diff --git a/libImaging/QuantHeap.c b/libImaging/QuantHeap.c
+index 9332a5c..bddcf14 100644
+--- a/libImaging/QuantHeap.c
++++ b/libImaging/QuantHeap.c
+@@ -21,31 +21,29 @@
+ #include <string.h>
+ #include <math.h>
+
+-#include "QuantHash.h"
+-#include "QuantDefines.h"
++#include "QuantHeap.h"
+
+-typedef struct {
++typedef struct _Heap {
+ void **heap;
+ int heapsize;
+ int heapcount;
+ HeapCmpFunc cf;
+-} IntHeap;
++} Heap;
+
+ #define INITIAL_SIZE 256
+
+-#define DEBUG
++// #define DEBUG
+
+ #ifdef DEBUG
+-static int _heap_test(Heap);
++static int _heap_test(Heap *);
+ #endif
+
+-void ImagingQuantHeapFree(Heap H) {
+- IntHeap *h=(IntHeap *)H;
++void ImagingQuantHeapFree(Heap *h) {
+ free(h->heap);
+ free(h);
+ }
+
+-static int _heap_grow(IntHeap *h,int newsize) {
++static int _heap_grow(Heap *h,int newsize) {
+ void *newheap;
+ if (!newsize) newsize=h->heapsize<<1;
+ if (newsize<h->heapsize) return 0;
+@@ -59,15 +57,14 @@ static int _heap_grow(IntHeap *h,int newsize) {
+ }
+
+ #ifdef DEBUG
+-static int _heap_test(Heap H) {
+- IntHeap *h=(IntHeap *)H;
++static int _heap_test(Heap *h) {
+ int k;
+ for (k=1;k*2<=h->heapcount;k++) {
+- if (h->cf(H,h->heap[k],h->heap[k*2])<0) {
++ if (h->cf(h,h->heap[k],h->heap[k*2])<0) {
+ printf ("heap is bad\n");
+ return 0;
+ }
+- if (k*2+1<=h->heapcount && h->cf(H,h->heap[k],h->heap[k*2+1])<0) {
++ if (k*2+1<=h->heapcount && h->cf(h,h->heap[k],h->heap[k*2+1])<0) {
+ printf ("heap is bad\n");
+ return 0;
+ }
+@@ -76,8 +73,7 @@ static int _heap_test(Heap H) {
+ }
+ #endif
+
+-int ImagingQuantHeapRemove(Heap H,void **r) {
+- IntHeap *h=(IntHeap *)H;
++int ImagingQuantHeapRemove(Heap* h,void **r) {
+ int k,l;
+ void *v;
+
+@@ -89,31 +85,30 @@ int ImagingQuantHeapRemove(Heap H,void **r) {
+ for (k=1;k*2<=h->heapcount;k=l) {
+ l=k*2;
+ if (l<h->heapcount) {
+- if (h->cf(H,h->heap[l],h->heap[l+1])<0) {
++ if (h->cf(h,h->heap[l],h->heap[l+1])<0) {
+ l++;
+ }
+ }
+- if (h->cf(H,v,h->heap[l])>0) {
++ if (h->cf(h,v,h->heap[l])>0) {
+ break;
+ }
+ h->heap[k]=h->heap[l];
+ }
+ h->heap[k]=v;
+ #ifdef DEBUG
+- if (!_heap_test(H)) { printf ("oops - heap_remove messed up the heap\n"); exit(1); }
++ if (!_heap_test(h)) { printf ("oops - heap_remove messed up the heap\n"); exit(1); }
+ #endif
+ return 1;
+ }
+
+-int ImagingQuantHeapAdd(Heap H,void *val) {
+- IntHeap *h=(IntHeap *)H;
++int ImagingQuantHeapAdd(Heap *h,void *val) {
+ int k;
+ if (h->heapcount==h->heapsize-1) {
+ _heap_grow(h,0);
+ }
+ k=++h->heapcount;
+ while (k!=1) {
+- if (h->cf(H,val,h->heap[k/2])<=0) {
++ if (h->cf(h,val,h->heap[k/2])<=0) {
+ break;
+ }
+ h->heap[k]=h->heap[k/2];
+@@ -121,13 +116,12 @@ int ImagingQuantHeapAdd(Heap H,void *val) {
+ }
+ h->heap[k]=val;
+ #ifdef DEBUG
+- if (!_heap_test(H)) { printf ("oops - heap_add messed up the heap\n"); exit(1); }
++ if (!_heap_test(h)) { printf ("oops - heap_add messed up the heap\n"); exit(1); }
+ #endif
+ return 1;
+ }
+
+-int ImagingQuantHeapTop(Heap H,void **r) {
+- IntHeap *h=(IntHeap *)H;
++int ImagingQuantHeapTop(Heap *h,void **r) {
+ if (!h->heapcount) {
+ return 0;
+ }
+@@ -136,15 +130,14 @@ int ImagingQuantHeapTop(Heap H,void **r) {
+ }
+
+ Heap *ImagingQuantHeapNew(HeapCmpFunc cf) {
+- IntHeap *h;
++ Heap *h;
+
+- h=malloc(sizeof(IntHeap));
++ h=malloc(sizeof(Heap));
+ if (!h) return NULL;
+ h->heapsize=INITIAL_SIZE;
+ h->heap=malloc(sizeof(void *)*h->heapsize);
+ if (!h->heap) { free(h); return NULL; }
+ h->heapcount=0;
+ h->cf=cf;
+- return (Heap)h;
++ return h;
+ }
+-
+diff --git a/libImaging/QuantHeap.h b/libImaging/QuantHeap.h
+index 5a213c4..77bf0d9 100644
+--- a/libImaging/QuantHeap.h
++++ b/libImaging/QuantHeap.h
+@@ -9,15 +9,19 @@
+ * See the README file for information on usage and redistribution.
+ */
+
+-#ifndef __HEAP_H__
+-#define __HEAP_H__
++#ifndef __QUANTHEAP_H__
++#define __QUANTHEAP_H__
+
+ #include "QuantTypes.h"
+
+-void ImagingQuantHeapFree(Heap);
+-int ImagingQuantHeapRemove(Heap,void **);
+-int ImagingQuantHeapAdd(Heap,void *);
+-int ImagingQuantHeapTop(Heap,void **);
++typedef struct _Heap Heap;
++
++typedef int (*HeapCmpFunc)(const Heap *,const void *,const void *);
++
++void ImagingQuantHeapFree(Heap *);
++int ImagingQuantHeapRemove(Heap *,void **);
++int ImagingQuantHeapAdd(Heap *,void *);
++int ImagingQuantHeapTop(Heap *,void **);
+ Heap *ImagingQuantHeapNew(HeapCmpFunc);
+
+-#endif
++#endif // __QUANTHEAP_H__
+diff --git a/libImaging/QuantOctree.c b/libImaging/QuantOctree.c
+index fcdf9e0..e841d6f 100644
+--- a/libImaging/QuantOctree.c
++++ b/libImaging/QuantOctree.c
+@@ -27,15 +27,15 @@
+ #include <stdlib.h>
+ #include <string.h>
+
+-#include "Quant.h"
++#include "QuantOctree.h"
+
+ typedef struct _ColorBucket{
+ /* contains palette index when used for look up cube */
+- unsigned long count;
+- unsigned long r;
+- unsigned long g;
+- unsigned long b;
+- unsigned long a;
++ uint32_t count;
++ uint32_t r;
++ uint32_t g;
++ uint32_t b;
++ uint32_t a;
+ } *ColorBucket;
+
+ typedef struct _ColorCube{
+@@ -262,7 +262,7 @@ set_lookup_value(const ColorCube cube, const Pixel *p, long value) {
+ bucket->count = value;
+ }
+
+-unsigned long
++uint32_t
+ lookup_color(const ColorCube cube, const Pixel *p) {
+ ColorBucket bucket = color_bucket_from_cube(cube, p);
+ return bucket->count;
+@@ -302,9 +302,9 @@ create_palette_array(const ColorBucket palette, unsigned int paletteLength) {
+
+ static void
+ map_image_pixels(const Pixel *pixelData,
+- unsigned long nPixels,
++ uint32_t nPixels,
+ const ColorCube lookupCube,
+- unsigned long *pixelArray)
++ uint32_t *pixelArray)
+ {
+ long i;
+ for (i=0; i<nPixels; i++) {
+@@ -316,11 +316,11 @@ const int CUBE_LEVELS[8] = {4, 4, 4, 0, 2, 2, 2, 0};
+ const int CUBE_LEVELS_ALPHA[8] = {3, 4, 3, 3, 2, 2, 2, 2};
+
+ int quantize_octree(Pixel *pixelData,
+- unsigned long nPixels,
+- unsigned long nQuantPixels,
++ uint32_t nPixels,
++ uint32_t nQuantPixels,
+ Pixel **palette,
+- unsigned long *paletteLength,
+- unsigned long **quantizedPixels,
++ uint32_t *paletteLength,
++ uint32_t **quantizedPixels,
+ int withAlpha)
+ {
+ ColorCube fineCube = NULL;
+@@ -330,7 +330,7 @@ int quantize_octree(Pixel *pixelData,
+ ColorBucket paletteBucketsCoarse = NULL;
+ ColorBucket paletteBucketsFine = NULL;
+ ColorBucket paletteBuckets = NULL;
+- unsigned long *qp = NULL;
++ uint32_t *qp = NULL;
+ long i;
+ long nCoarseColors, nFineColors, nAlreadySubtracted;
+ const int *cubeBits;
+diff --git a/libImaging/QuantOctree.h b/libImaging/QuantOctree.h
+index fd7b7db..968644e 100644
+--- a/libImaging/QuantOctree.h
++++ b/libImaging/QuantOctree.h
+@@ -1,12 +1,14 @@
+ #ifndef __QUANT_OCTREE_H__
+ #define __QUANT_OCTREE_H__
+
++#include "QuantTypes.h"
++
+ int quantize_octree(Pixel *,
+- unsigned long,
+- unsigned long,
++ uint32_t,
++ uint32_t,
+ Pixel **,
+- unsigned long *,
+- unsigned long **,
++ uint32_t *,
++ uint32_t **,
+ int);
+
+-#endif
+\ No newline at end of file
++#endif
+diff --git a/libImaging/QuantTypes.h b/libImaging/QuantTypes.h
+index 308b51c..8f113b0 100644
+--- a/libImaging/QuantTypes.h
++++ b/libImaging/QuantTypes.h
+@@ -12,17 +12,20 @@
+ #ifndef __TYPES_H__
+ #define __TYPES_H__
+
+-typedef void *HashTable;
+-typedef void *Heap;
+-
+-typedef unsigned long (*HashFunc)(const HashTable,const void *);
+-typedef int (*HashCmpFunc)(const HashTable,const void *,const void *);
+-typedef void (*IteratorFunc)(const HashTable,const void *,const void *,void *);
+-typedef void (*IteratorUpdateFunc)(const HashTable,const void *,void **,void *);
+-typedef void (*DestroyFunc)(const HashTable,void *);
+-typedef void (*ComputeFunc)(const HashTable,const void *,void **);
+-typedef void (*CollisionFunc)(const HashTable,void **,void **,void *,void *);
++#ifdef _MSC_VER
++typedef unsigned __int32 uint32_t;
++#else
++#include <stdint.h>
++#endif
+
+-typedef int (*HeapCmpFunc)(const Heap,const void *,const void *);
++typedef union {
++ struct {
++ unsigned char r,g,b,a;
++ } c;
++ struct {
++ unsigned char v[4];
++ } a;
++ uint32_t v;
++} Pixel;
+
+ #endif
More information about the scm-commits
mailing list