ydb/contrib/python/Pillow/py2/libImaging/Quant.c

/*
 * The Python Imaging Library
 * $Id$
 *
 * image quantizer
 *
 * history:
 * 1998-09-10 tjs  Contributed
 * 1998-12-29 fl   Added to PIL 1.0b1
 * 2004-02-21 fl   Fixed bogus free() on quantization error
 * 2005-02-07 fl   Limit number of colors to 256
 *
 * Written by Toby J Sargeant <tjs@longford.cs.monash.edu.au>.
 *
 * Copyright (c) 1998 by Toby J Sargeant
 * Copyright (c) 1998-2004 by Secret Labs AB.  All rights reserved.
 *
 * See the README file for information on usage and redistribution.
 */

#include "Imaging.h"

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <time.h>

#include "QuantTypes.h"
#include "QuantOctree.h"
#include "QuantPngQuant.h"
#include "QuantHash.h"
#include "QuantHeap.h"

/* MSVC9.0 */
#ifndef UINT32_MAX
#define UINT32_MAX 0xffffffff
#endif

#define NO_OUTPUT

typedef struct {
    uint32_t scale;
} PixelHashData;

typedef struct _PixelList {
    struct _PixelList *next[3],*prev[3];
    Pixel p;
    unsigned int flag:1;
    int count;
} PixelList;

typedef struct _BoxNode {
    struct _BoxNode *l,*r;
    PixelList *head[3],*tail[3];
    int axis;
    int volume;
    uint32_t pixelCount;
} BoxNode;

#define _SQR(x) ((x)*(x))
#define _DISTSQR(p1,p2) \
    _SQR((int)((p1)->c.r)-(int)((p2)->c.r))+ \
    _SQR((int)((p1)->c.g)-(int)((p2)->c.g))+ \
    _SQR((int)((p1)->c.b)-(int)((p2)->c.b))

#define MAX_HASH_ENTRIES 65536

#define PIXEL_HASH(r,g,b) \
    (((unsigned int)(r)    )*463 ^ \
     ((unsigned int)(g)<< 8)*10069 ^ \
     ((unsigned int)(b)<<16)*64997)

#define PIXEL_UNSCALE(p,q,s) \
    ((q)->c.r=(p)->c.r<<(s)), \
    ((q)->c.g=(p)->c.g<<(s)), \
    ((q)->c.b=(p)->c.b<<(s))

#define PIXEL_SCALE(p,q,s)\
    ((q)->c.r=(p)->c.r>>(s)),              \
    ((q)->c.g=(p)->c.g>>(s)),              \
    ((q)->c.b=(p)->c.b>>(s))

static uint32_t
unshifted_pixel_hash(const HashTable *h, const Pixel pixel)
{
   return PIXEL_HASH(pixel.c.r, pixel.c.g, pixel.c.b);
}

static int
unshifted_pixel_cmp(const HashTable *h, const Pixel pixel1, const Pixel pixel2)
{
    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);
            }
        } else {
            return (int)(pixel1.c.g)-(int)(pixel2.c.g);
        }
    } else {
        return (int)(pixel1.c.r)-(int)(pixel2.c.r);
    }
}

static uint32_t
pixel_hash(const HashTable *h,const Pixel pixel)
{
    PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
    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 Pixel pixel1, const Pixel pixel2)
{
    PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
    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 Pixel key, uint32_t *val)
{
    *val+=1;
}

static void
new_count_func(const HashTable *h, const Pixel key, uint32_t *val)
{
    *val=1;
}

static void
rehash_collide(const HashTable *h,
               Pixel *keyp,
               uint32_t *valp,
               Pixel newkey,
               uint32_t newval)
{
    *valp += newval;
}

/* %% */

static HashTable *
create_pixel_hash(Pixel *pixelData,uint32_t nPixels)
{
   PixelHashData *d;
   HashTable *hash;
   uint32_t i;
#ifndef NO_OUTPUT
   uint32_t timer,timer2,timer3;
#endif

   /* malloc check ok, small constant allocation */
   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,
                                              pixelData[i],
                                              new_count_func,
                                              exists_count_func)) {;
      }
      while (hashtable_get_count(hash)>MAX_HASH_ENTRIES) {
         d->scale++;
#ifndef NO_OUTPUT
         printf ("rehashing - new scale: %d\n",(int)d->scale);
         timer2=clock();
#endif
         hashtable_rehash_compute(hash,rehash_collide);
#ifndef NO_OUTPUT
         timer2=clock()-timer2;
         printf ("rehash took %f sec\n",timer2/(double)CLOCKS_PER_SEC);
         timer+=timer2;
#endif
      }
   }
#ifndef NO_OUTPUT
   printf ("inserts took %f sec\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif
#ifndef NO_OUTPUT
   printf ("total        %f sec\n",(clock()-timer3)/(double)CLOCKS_PER_SEC);
#endif
   return hash;
}

static void
destroy_pixel_hash(HashTable *hash)
{
   PixelHashData *d=(PixelHashData *)hashtable_get_user_data(hash);
   if (d) free(d);
   hashtable_free(hash);
}


/* 1. hash quantized pixels.                                                  */
/* 2. create R,G,B lists of sorted quantized pixels.                          */
/* 3. median cut.                                                             */
/* 4. build hash table from median cut boxes.                                 */
/* 5. for each pixel, compute entry in hash table, and hence median cut box.  */
/* 6. compute median cut box pixel averages.                                  */
/* 7. map each pixel to nearest average.                                      */

static int
compute_box_volume(BoxNode *b)
{
   unsigned char rl,rh,gl,gh,bl,bh;
   if (b->volume>=0) return b->volume;
   if (!b->head[0]) {
      b->volume=0;
   } else {
      rh=b->head[0]->p.c.r;
      rl=b->tail[0]->p.c.r;
      gh=b->head[1]->p.c.g;
      gl=b->tail[1]->p.c.g;
      bh=b->head[2]->p.c.b;
      bl=b->tail[2]->p.c.b;
      b->volume=(rh-rl+1)*(gh-gl+1)*(bh-bl+1);
   }
   return b->volume;
}

static void
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;
   int i;
   Pixel q;

   PIXEL_SCALE(&pixel,&q,d->scale);

   /* malloc check ok, small constant allocation */
   p=malloc(sizeof(PixelList));
   if (!p) return;

   p->flag=0;
   p->p=q;
   p->count=count;
   for (i=0;i<3;i++) {
      p->next[i]=pl[i];
      p->prev[i]=NULL;
      if (pl[i]) pl[i]->prev[i]=p;
      pl[i]=p;
   }
}

static PixelList *
mergesort_pixels(PixelList *head, int i)
{
   PixelList *c,*t,*a,*b,*p;
   if (!head||!head->next[i]) {
      if (head) {
         head->next[i]=NULL;
         head->prev[i]=NULL;
      }
      return head;
   }
   for (c=t=head;c&&t;c=c->next[i],t=(t->next[i])?t->next[i]->next[i]:NULL);
   if (c) {
      if (c->prev[i]) c->prev[i]->next[i]=NULL;
      c->prev[i]=NULL;
   }
   a=mergesort_pixels(head,i);
   b=mergesort_pixels(c,i);
   head=NULL;
   p=NULL;
   while (a&&b) {
      if (a->p.a.v[i]>b->p.a.v[i]) {
         c=a;
         a=a->next[i];
      } else {
         c=b;
         b=b->next[i];
      }
      c->prev[i]=p;
      c->next[i]=NULL;
      if (p) p->next[i]=c;
      p=c;
      if (!head) head=c;
   }
   if (a) {
      c->next[i]=a;
      a->prev[i]=c;
   } else if (b) {
      c->next[i]=b;
      b->prev[i]=c;
   }
   return head;
}

#if defined(TEST_MERGESORT) || defined(TEST_SORTED)
static int
test_sorted(PixelList *pl[3])
{
   int i,n,l;
   PixelList *t;

   for(i=0;i<3;i++) {
      n=0;
      l=256;
      for (t=pl[i];t;t=t->next[i]) {
         if (l<t->p.a.v[i]) return 0;
         l=t->p.a.v[i];
      }
   }
   return 1;
}
#endif

static int
box_heap_cmp(const Heap *h, const void *A, const void *B)
{
   BoxNode *a=(BoxNode *)A;
   BoxNode *b=(BoxNode *)B;
   return (int)a->pixelCount-(int)b->pixelCount;
}

#define LUMINANCE(p) (77*(p)->c.r+150*(p)->c.g+29*(p)->c.b)

static int
splitlists(PixelList *h[3],
           PixelList *t[3],
           PixelList *nh[2][3],
           PixelList *nt[2][3],
           uint32_t nCount[2],
           int axis,
           uint32_t pixelCount)
{
   uint32_t left;

   PixelList *l,*r,*c,*n;
   int i;
   int nRight,nLeft;
   int splitColourVal;

#ifdef TEST_SPLIT
   {
      PixelList *_prevTest,*_nextTest;
      int _i,_nextCount[3],_prevCount[3];
      for (_i=0;_i<3;_i++) {
         for (_nextCount[_i]=0,_nextTest=h[_i];_nextTest&&_nextTest->next[_i];_nextTest=_nextTest->next[_i],_nextCount[_i]++);
         for (_prevCount[_i]=0,_prevTest=t[_i];_prevTest&&_prevTest->prev[_i];_prevTest=_prevTest->prev[_i],_prevCount[_i]++);
         if (_nextTest!=t[_i]) {
            printf ("next-list of axis %d does not end at tail\n",_i);
            exit(1);
         }
         if (_prevTest!=h[_i]) {
            printf ("prev-list of axis %d does not end at head\n",_i);
            exit(1);
         }
         for (;_nextTest&&_nextTest->prev[_i];_nextTest=_nextTest->prev[_i]);
         for (;_prevTest&&_prevTest->next[_i];_prevTest=_prevTest->next[_i]);
         if (_nextTest!=h[_i]) {
            printf ("next-list of axis %d does not loop back to head\n",_i);
            exit(1);
         }
         if (_prevTest!=t[_i]) {
            printf ("prev-list of axis %d does not loop back to tail\n",_i);
            exit(1);
         }
      }
      for (_i=1;_i<3;_i++) {
         if (_prevCount[_i]!=_prevCount[_i-1] ||
             _nextCount[_i]!=_nextCount[_i-1] ||
             _prevCount[_i]!=_nextCount[_i]) {
            printf ("{%d %d %d} {%d %d %d}\n",
                    _prevCount[0],
                    _prevCount[1],
                    _prevCount[2],
                    _nextCount[0],
                    _nextCount[1],
                    _nextCount[2]);
            exit(1);
         }
      }
    }
#endif
   nCount[0]=nCount[1]=0;
   nLeft=nRight=0;
   for (left=0,c=h[axis];c;) {
      left=left+c->count;
      nCount[0]+=c->count;
      c->flag=0;
      nLeft++;
      c=c->next[axis];
      if (left*2>pixelCount) {
         break;
      }
   }
   if (c) {
      splitColourVal=c->prev[axis]->p.a.v[axis];
      for (;c;c=c->next[axis]) {
         if (splitColourVal!=c->p.a.v[axis]) {
            break;
         }
         c->flag=0;
         nLeft++;
         nCount[0]+=c->count;
      }
   }
   for (;c;c=c->next[axis]) {
      c->flag=1;
      nRight++;
      nCount[1]+=c->count;
   }
   if (!nRight) {
      for (c=t[axis],splitColourVal=t[axis]->p.a.v[axis];c;c=c->prev[axis]) {
         if (splitColourVal!=c->p.a.v[axis]) {
            break;
         }
         c->flag=1;
         nRight++;
         nLeft--;
         nCount[0]-=c->count;
         nCount[1]+=c->count;
      }
   }
#ifndef NO_OUTPUT
   if (!nLeft) {
      for (c=h[axis];c;c=c->next[axis]) {
         printf ("[%d %d %d]\n",c->p.c.r,c->p.c.g,c->p.c.b);
      }
      printf ("warning... trivial split\n");
   }
#endif

   for (i=0;i<3;i++) {
      l=r=NULL;
      nh[0][i]=nt[0][i]=NULL;
      nh[1][i]=nt[1][i]=NULL;
      for (c=h[i];c;c=n) {
         n=c->next[i];
         if (c->flag) {    /* move pixel to right  list*/
            if (r) r->next[i]=c; else nh[1][i]=c;
            c->prev[i]=r;
            r=c;
         } else {          /* move pixel to left list */
            if (l) l->next[i]=c; else nh[0][i]=c;
            c->prev[i]=l;
            l=c;
         }
      }
      if (l) l->next[i]=NULL;
      if (r) r->next[i]=NULL;
      nt[0][i]=l;
      nt[1][i]=r;
   }
   return 1;
}

static int
split(BoxNode *node)
{
   unsigned char rl,rh,gl,gh,bl,bh;
   int f[3];
   int best,axis;
   int i;
   PixelList *heads[2][3];
   PixelList *tails[2][3];
   uint32_t newCounts[2];
   BoxNode *left,*right;

   rh=node->head[0]->p.c.r;
   rl=node->tail[0]->p.c.r;
   gh=node->head[1]->p.c.g;
   gl=node->tail[1]->p.c.g;
   bh=node->head[2]->p.c.b;
   bl=node->tail[2]->p.c.b;
#ifdef TEST_SPLIT
   printf ("splitting node [%d %d %d] [%d %d %d] ",rl,gl,bl,rh,gh,bh);
#endif
   f[0]=(rh-rl)*77;
   f[1]=(gh-gl)*150;
   f[2]=(bh-bl)*29;

   best=f[0];
   axis=0;
   for (i=1;i<3;i++) {
      if (best<f[i]) { best=f[i]; axis=i; }
   }
#ifdef TEST_SPLIT
   printf ("along axis %d\n",axis+1);
#endif

#ifdef TEST_SPLIT
   {
      PixelList *_prevTest,*_nextTest;
      int _i,_nextCount[3],_prevCount[3];
      for (_i=0;_i<3;_i++) {
         if (node->tail[_i]->next[_i]) {
            printf ("tail is not tail\n");
            printf ("node->tail[%d]->next[%d]=%p\n",_i,_i,node->tail[_i]->next[_i]);
         }
         if (node->head[_i]->prev[_i]) {
            printf ("head is not head\n");
            printf ("node->head[%d]->prev[%d]=%p\n",_i,_i,node->head[_i]->prev[_i]);
         }
      }

      for (_i=0;_i<3;_i++) {
         for (_nextCount[_i]=0,_nextTest=node->head[_i];_nextTest&&_nextTest->next[_i];_nextTest=_nextTest->next[_i],_nextCount[_i]++);
         for (_prevCount[_i]=0,_prevTest=node->tail[_i];_prevTest&&_prevTest->prev[_i];_prevTest=_prevTest->prev[_i],_prevCount[_i]++);
         if (_nextTest!=node->tail[_i]) {
            printf ("next-list of axis %d does not end at tail\n",_i);
         }
         if (_prevTest!=node->head[_i]) {
            printf ("prev-list of axis %d does not end at head\n",_i);
         }
         for (;_nextTest&&_nextTest->prev[_i];_nextTest=_nextTest->prev[_i]);
         for (;_prevTest&&_prevTest->next[_i];_prevTest=_prevTest->next[_i]);
         if (_nextTest!=node->head[_i]) {
            printf ("next-list of axis %d does not loop back to head\n",_i);
         }
         if (_prevTest!=node->tail[_i]) {
            printf ("prev-list of axis %d does not loop back to tail\n",_i);
         }
      }
      for (_i=1;_i<3;_i++) {
         if (_prevCount[_i]!=_prevCount[_i-1] ||
             _nextCount[_i]!=_nextCount[_i-1] ||
             _prevCount[_i]!=_nextCount[_i]) {
            printf ("{%d %d %d} {%d %d %d}\n",
                    _prevCount[0],
                    _prevCount[1],
                    _prevCount[2],
                    _nextCount[0],
                    _nextCount[1],
                    _nextCount[2]);
         }
      }
    }
#endif
   node->axis=axis;
   if (!splitlists(node->head,
                   node->tail,
                   heads,
                   tails,
                   newCounts,
                   axis,
                   node->pixelCount)) {
#ifndef NO_OUTPUT
      printf ("list split failed.\n");
#endif
      return 0;
   }
#ifdef TEST_SPLIT
   if (!test_sorted(heads[0])) {
      printf ("bug in split");
      exit(1);
   }
   if (!test_sorted(heads[1])) {
      printf ("bug in split");
      exit(1);
   }
#endif
   /* malloc check ok, small constant allocation */
   left=malloc(sizeof(BoxNode));
   right=malloc(sizeof(BoxNode));
   if (!left||!right) {
      free(left);
      free(right);
      return 0;
   }
   for(i=0;i<3;i++) {
      left->head[i]=heads[0][i];
      left->tail[i]=tails[0][i];
      right->head[i]=heads[1][i];
      right->tail[i]=tails[1][i];
      node->head[i]=NULL;
      node->tail[i]=NULL;
   }
#ifdef TEST_SPLIT
   if (left->head[0]) {
      rh=left->head[0]->p.c.r;
      rl=left->tail[0]->p.c.r;
      gh=left->head[1]->p.c.g;
      gl=left->tail[1]->p.c.g;
      bh=left->head[2]->p.c.b;
      bl=left->tail[2]->p.c.b;
      printf ("   left node  [%3d %3d %3d] [%3d %3d %3d]\n",rl,gl,bl,rh,gh,bh);
   }
   if (right->head[0]) {
      rh=right->head[0]->p.c.r;
      rl=right->tail[0]->p.c.r;
      gh=right->head[1]->p.c.g;
      gl=right->tail[1]->p.c.g;
      bh=right->head[2]->p.c.b;
      bl=right->tail[2]->p.c.b;
      printf ("   right node [%3d %3d %3d] [%3d %3d %3d]\n",rl,gl,bl,rh,gh,bh);
   }
#endif
   left->l=left->r=NULL;
   right->l=right->r=NULL;
   left->axis=right->axis=-1;
   left->volume=right->volume=-1;
   left->pixelCount=newCounts[0];
   right->pixelCount=newCounts[1];
   node->l=left;
   node->r=right;
   return 1;
}

static BoxNode *
median_cut(PixelList *hl[3],
           uint32_t imPixelCount,
           int nPixels)
{
   PixelList *tl[3];
   int i;
   BoxNode *root;
   Heap* h;
   BoxNode *thisNode;

   h=ImagingQuantHeapNew(box_heap_cmp);
   /* malloc check ok, small constant allocation */
   root=malloc(sizeof(BoxNode));
   if (!root) { ImagingQuantHeapFree(h); return NULL; }
   for(i=0;i<3;i++) {
      for (tl[i]=hl[i];tl[i]&&tl[i]->next[i];tl[i]=tl[i]->next[i]);
      root->head[i]=hl[i];
      root->tail[i]=tl[i];
   }
   root->l=root->r=NULL;
   root->axis=-1;
   root->volume=-1;
   root->pixelCount=imPixelCount;

   ImagingQuantHeapAdd(h,(void *)root);
   while (--nPixels) {
      do {
         if (!ImagingQuantHeapRemove(h,(void **)&thisNode)) {
            goto done;
         }
      } while (compute_box_volume(thisNode)==1);
      if (!split(thisNode)) {
#ifndef NO_OUTPUT
         printf ("Oops, split failed...\n");
#endif
         exit (1);
      }
      ImagingQuantHeapAdd(h,(void *)(thisNode->l));
      ImagingQuantHeapAdd(h,(void *)(thisNode->r));
   }
done:
   ImagingQuantHeapFree(h);
   return root;
}

static void
free_box_tree(BoxNode *n)
{
   PixelList *p,*pp;
   if (n->l) free_box_tree(n->l);
   if (n->r) free_box_tree(n->r);
   for (p=n->head[0];p;p=pp) {
      pp=p->next[0];
      free(p);
   }
   free(n);
}

#ifdef TEST_SPLIT_INTEGRITY
static int
checkContained(BoxNode *n,Pixel *pp)
{
   if (n->l&&n->r) {
      return checkContained(n->l,pp)+checkContained(n->r,pp);
   }
   if (n->l||n->r) {
#ifndef NO_OUTPUT
      printf ("box tree is dead\n");
#endif
      return 0;
   }
   if (
       pp->c.r<=n->head[0]->p.c.r &&
       pp->c.r>=n->tail[0]->p.c.r &&
       pp->c.g<=n->head[1]->p.c.g &&
       pp->c.g>=n->tail[1]->p.c.g &&
       pp->c.b<=n->head[2]->p.c.b &&
       pp->c.b>=n->tail[2]->p.c.b) {
      return 1;
   }
   return 0;
}
#endif

static int
annotate_hash_table(BoxNode *n,HashTable *h,uint32_t *box)
{
   PixelList *p;
   PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
   Pixel q;
   if (n->l&&n->r) {
      return annotate_hash_table(n->l,h,box) && annotate_hash_table(n->r,h,box);
   }
   if (n->l||n->r) {
#ifndef NO_OUTPUT
      printf ("box tree is dead\n");
#endif
      return 0;
   }
   for (p=n->head[0];p;p=p->next[0]) {
      PIXEL_UNSCALE(&(p->p),&q,d->scale);
      if (!hashtable_insert(h,q,*box)) {
#ifndef NO_OUTPUT
         printf ("hashtable insert failed\n");
#endif
         return 0;
      }
   }
   if (n->head[0]) (*box)++;
   return 1;
}

static int
_sort_ulong_ptr_keys(const void *a, const void *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(uint32_t *avgDist,
                       uint32_t **avgDistSortKey,
                       Pixel *p,
                       uint32_t nEntries)
{
   uint32_t i,j,k;
   uint32_t **skRow;
   uint32_t *skElt;

   for (i=0;i<nEntries;i++) {
      avgDist[i*nEntries+i]=0;
      for (j=0;j<i;j++) {
         avgDist[j*nEntries+i]=
         avgDist[i*nEntries+j]=_DISTSQR(p+i,p+j);
      }
   }
   for (i=0;i<nEntries;i++) {
      skRow=avgDistSortKey+i*nEntries;
      for (j=1;j<nEntries;j++) {
         skElt=skRow[j];
         for (k=j;k&&(*(skRow[k-1])>*(skRow[k]));k--) {
            skRow[k]=skRow[k-1];
         }
         if (k!=j) skRow[k]=skElt;
      }
   }
   return 1;
}

static int
build_distance_tables(uint32_t *avgDist,
                      uint32_t **avgDistSortKey,
                      Pixel *p,
                      uint32_t nEntries)
{
   uint32_t i,j;

   for (i=0;i<nEntries;i++) {
      avgDist[i*nEntries+i]=0;
      avgDistSortKey[i*nEntries+i]=&(avgDist[i*nEntries+i]);
      for (j=0;j<i;j++) {
         avgDist[j*nEntries+i]=
         avgDist[i*nEntries+j]=_DISTSQR(p+i,p+j);
         avgDistSortKey[j*nEntries+i]=&(avgDist[j*nEntries+i]);
         avgDistSortKey[i*nEntries+j]=&(avgDist[i*nEntries+j]);
      }
   }
   for (i=0;i<nEntries;i++) {
      qsort(avgDistSortKey+i*nEntries,
            nEntries,
            sizeof(uint32_t *),
            _sort_ulong_ptr_keys);
   }
   return 1;
}

static int
map_image_pixels(Pixel *pixelData,
                 uint32_t nPixels,
                 Pixel *paletteData,
                 uint32_t nPaletteEntries,
                 uint32_t *avgDist,
                 uint32_t **avgDistSortKey,
                 uint32_t *pixelArray)
{
   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,pixelData[i],&bestmatch)) {
         bestmatch=0;
         initialdist=_DISTSQR(paletteData+bestmatch,pixelData+i);
         bestdist=initialdist;
         initialdist<<=2;
         aDSK=avgDistSortKey+bestmatch*nPaletteEntries;
         aD=avgDist+bestmatch*nPaletteEntries;
         for (j=0;j<nPaletteEntries;j++) {
            idx=aDSK[j]-aD;
            if (*(aDSK[j])<=initialdist)  {
               dist=_DISTSQR(paletteData+idx,pixelData+i);
               if (dist<bestdist) {
                  bestdist=dist;
                  bestmatch=idx;
               }
            } else {
               break;
            }
         }
         hashtable_insert(h2,pixelData[i],bestmatch);
      }
      pixelArray[i]=bestmatch;
   }
   hashtable_free(h2);
   return 1;
}

static int
map_image_pixels_from_quantized_pixels(
    Pixel *pixelData,
    uint32_t nPixels,
    Pixel *paletteData,
    uint32_t nPaletteEntries,
    uint32_t *avgDist,
    uint32_t **avgDistSortKey,
    uint32_t *pixelArray,
    uint32_t *avg[3],
    uint32_t *count)
{
   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,pixelData[i],&bestmatch)) {
         bestmatch=pixelArray[i];
         initialdist=_DISTSQR(paletteData+bestmatch,pixelData+i);
         bestdist=initialdist;
         initialdist<<=2;
         aDSK=avgDistSortKey+bestmatch*nPaletteEntries;
         aD=avgDist+bestmatch*nPaletteEntries;
         for (j=0;j<nPaletteEntries;j++) {
            idx=aDSK[j]-aD;
            if (*(aDSK[j])<=initialdist)  {
               dist=_DISTSQR(paletteData+idx,pixelData+i);
               if (dist<bestdist) {
                  bestdist=dist;
                  bestmatch=idx;
               }
            } else {
               break;
            }
         }
         hashtable_insert(h2,pixelData[i],bestmatch);
      }
      if (pixelArray[i]!=bestmatch) {
         changes++;
         avg[0][bestmatch]+=pixelData[i].c.r;
         avg[1][bestmatch]+=pixelData[i].c.g;
         avg[2][bestmatch]+=pixelData[i].c.b;
         avg[0][pixelArray[i]]-=pixelData[i].c.r;
         avg[1][pixelArray[i]]-=pixelData[i].c.g;
         avg[2][pixelArray[i]]-=pixelData[i].c.b;
         count[bestmatch]++;
         count[pixelArray[i]]--;
         pixelArray[i]=bestmatch;
      }
   }
   hashtable_free(h2);
   return changes;
}

static int
map_image_pixels_from_median_box(
    Pixel *pixelData,
    uint32_t nPixels,
    Pixel *paletteData,
    uint32_t nPaletteEntries,
    HashTable *medianBoxHash,
    uint32_t *avgDist,
    uint32_t **avgDistSortKey,
    uint32_t *pixelArray)
{
   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,pixelData[i],&pixelVal)) {
         pixelArray[i]=pixelVal;
         continue;
      }
      if (!hashtable_lookup(medianBoxHash,pixelData[i],&pixelVal)) {
#ifndef NO_OUTPUT
         printf ("pixel lookup failed\n");
#endif
         return 0;
      }
      initialdist=_DISTSQR(paletteData+pixelVal,pixelData+i);
      bestdist=initialdist;
      bestmatch=pixelVal;
      initialdist<<=2;
      aDSK=avgDistSortKey+pixelVal*nPaletteEntries;
      aD=avgDist+pixelVal*nPaletteEntries;
      for (j=0;j<nPaletteEntries;j++) {
         idx=aDSK[j]-aD;
         if (*(aDSK[j])<=initialdist)  {
            dist=_DISTSQR(paletteData+idx,pixelData+i);
            if (dist<bestdist) {
               bestdist=dist;
               bestmatch=idx;
            }
         } else {
            break;
         }
      }
      pixelArray[i]=bestmatch;
      hashtable_insert(h2,pixelData[i],bestmatch);
   }
   hashtable_free(h2);
   return 1;
}

static int
compute_palette_from_median_cut(
    Pixel *pixelData,
    uint32_t nPixels,
    HashTable *medianBoxHash,
    Pixel **palette,
    uint32_t nPaletteEntries)
{
   uint32_t i;
   uint32_t paletteEntry;
   Pixel *p;
   uint32_t *avg[3];
   uint32_t *count;

   *palette=NULL;
   /* malloc check ok, using calloc */
   if (!(count=calloc(nPaletteEntries, sizeof(uint32_t)))) {
      return 0;
   }
   for(i=0;i<3;i++) {
      avg[i]=NULL;
   }
   for(i=0;i<3;i++) {
      /* malloc check ok, using calloc */
      if (!(avg[i]=calloc(nPaletteEntries, sizeof(uint32_t)))) {
         for(i=0;i<3;i++) {
            if (avg[i]) free (avg[i]);
         }
         free(count);
         return 0;
      }
   }
   for (i=0;i<nPixels;i++) {
#ifdef TEST_SPLIT_INTEGRITY
      if (!(i%100)) { printf ("%05d\r",i); fflush(stdout); }
      if (checkContained(root,pixelData+i)>1) {
         printf ("pixel in two boxes\n");
         for(i=0;i<3;i++) free (avg[i]);
         free(count);
         return 0;
      }
#endif
      if (!hashtable_lookup(medianBoxHash,pixelData[i],&paletteEntry)) {
#ifndef NO_OUTPUT
         printf ("pixel lookup failed\n");
#endif
         for(i=0;i<3;i++) free (avg[i]);
         free(count);
         return 0;
      }
      if (paletteEntry>=nPaletteEntries) {
#ifndef NO_OUTPUT
         printf ("panic - paletteEntry>=nPaletteEntries (%d>=%d)\n",(int)paletteEntry,(int)nPaletteEntries);
#endif
         for(i=0;i<3;i++) free (avg[i]);
         free(count);
         return 0;
      }
      avg[0][paletteEntry]+=pixelData[i].c.r;
      avg[1][paletteEntry]+=pixelData[i].c.g;
      avg[2][paletteEntry]+=pixelData[i].c.b;
      count[paletteEntry]++;
   }
   /* malloc check ok, using calloc */
   p=calloc(nPaletteEntries, sizeof(Pixel));
   if (!p) {
      for(i=0;i<3;i++) free (avg[i]);
      free(count);
      return 0;
   }
   for (i=0;i<nPaletteEntries;i++) {
      p[i].c.r=(int)(.5+(double)avg[0][i]/(double)count[i]);
      p[i].c.g=(int)(.5+(double)avg[1][i]/(double)count[i]);
      p[i].c.b=(int)(.5+(double)avg[2][i]/(double)count[i]);
   }
   *palette=p;
   for(i=0;i<3;i++) free (avg[i]);
   free(count);
   return 1;
}

static int
recompute_palette_from_averages(
    Pixel *palette,
    uint32_t nPaletteEntries,
    uint32_t *avg[3],
    uint32_t *count)
{
    uint32_t i;

    for (i=0;i<nPaletteEntries;i++) {
        palette[i].c.r=(int)(.5+(double)avg[0][i]/(double)count[i]);
        palette[i].c.g=(int)(.5+(double)avg[1][i]/(double)count[i]);
        palette[i].c.b=(int)(.5+(double)avg[2][i]/(double)count[i]);
    }
    return 1;
}

static int
compute_palette_from_quantized_pixels(
    Pixel *pixelData,
    uint32_t nPixels,
    Pixel *palette,
    uint32_t nPaletteEntries,
    uint32_t *avg[3],
    uint32_t *count,
    uint32_t *qp)
{
   uint32_t i;

   memset(count,0,sizeof(uint32_t)*nPaletteEntries);
   for(i=0;i<3;i++) {
      memset(avg[i],0,sizeof(uint32_t)*nPaletteEntries);
   }
   for (i=0;i<nPixels;i++) {
      if (qp[i]>=nPaletteEntries) {
#ifndef NO_OUTPUT
         printf ("scream\n");
#endif
         return 0;
      }
      avg[0][qp[i]]+=pixelData[i].c.r;
      avg[1][qp[i]]+=pixelData[i].c.g;
      avg[2][qp[i]]+=pixelData[i].c.b;
      count[qp[i]]++;
   }
   for (i=0;i<nPaletteEntries;i++) {
      palette[i].c.r=(int)(.5+(double)avg[0][i]/(double)count[i]);
      palette[i].c.g=(int)(.5+(double)avg[1][i]/(double)count[i]);
      palette[i].c.b=(int)(.5+(double)avg[2][i]/(double)count[i]);
   }
   return 1;
}

static int
k_means(Pixel *pixelData,
        uint32_t nPixels,
        Pixel *paletteData,
        uint32_t nPaletteEntries,
        uint32_t *qp,
        int threshold)
{
   uint32_t *avg[3];
   uint32_t *count;
   uint32_t i;
   uint32_t *avgDist;
   uint32_t **avgDistSortKey;
   int changes;
   int built=0;

   if (nPaletteEntries > UINT32_MAX / (sizeof(uint32_t))) {
       return 0;
   }
   /* malloc check ok, using calloc */
   if (!(count=calloc(nPaletteEntries, sizeof(uint32_t)))) {
      return 0;
   }
   for(i=0;i<3;i++) {
      avg[i]=NULL;
   }
   for(i=0;i<3;i++) {
      /* malloc check ok, using calloc */
      if (!(avg[i]=calloc(nPaletteEntries, sizeof(uint32_t)))) {
         goto error_1;
      }
   }

   /* this is enough of a check, since the multiplication n*size is done above */
   if (nPaletteEntries > UINT32_MAX / nPaletteEntries) {
       goto error_1;
   }
   /* malloc check ok, using calloc, checking n*n above */
   avgDist=calloc(nPaletteEntries*nPaletteEntries, sizeof(uint32_t));
   if (!avgDist) { goto error_1; }

   /* malloc check ok, using calloc, checking n*n above */
   avgDistSortKey=calloc(nPaletteEntries*nPaletteEntries, sizeof(uint32_t *));
   if (!avgDistSortKey) { goto error_2; }

#ifndef NO_OUTPUT
   printf("[");fflush(stdout);
#endif
   while (1) {
      if (!built) {
         compute_palette_from_quantized_pixels(pixelData,nPixels,paletteData,nPaletteEntries,avg,count,qp);
         build_distance_tables(avgDist,avgDistSortKey,paletteData,nPaletteEntries);
         built=1;
      } else {
         recompute_palette_from_averages(paletteData,nPaletteEntries,avg,count);
         resort_distance_tables(avgDist,avgDistSortKey,paletteData,nPaletteEntries);
      }
      changes=map_image_pixels_from_quantized_pixels(pixelData,
                                                     nPixels,
                                                     paletteData,
                                                     nPaletteEntries,
                                                     avgDist,
                                                     avgDistSortKey,
                                                     qp,
                                                     avg,
                                                     count);
      if (changes<0) {
         goto error_3;
      }
#ifndef NO_OUTPUT
      printf (".(%d)",changes);fflush(stdout);
#endif
      if (changes<=threshold) break;
   }
#ifndef NO_OUTPUT
   printf("]\n");
#endif
   if (avgDistSortKey) free(avgDistSortKey);
   if (avgDist) free(avgDist);
   for(i=0;i<3;i++) if (avg[i]) free (avg[i]);
   if (count) free(count);
   return 1;

error_3:
   if (avgDistSortKey) free(avgDistSortKey);
error_2:
   if (avgDist) free(avgDist);
error_1:
   for(i=0;i<3;i++) if (avg[i]) free (avg[i]);
   if (count) free(count);
   return 0;
}

int
quantize(Pixel *pixelData,
         uint32_t nPixels,
         uint32_t nQuantPixels,
         Pixel **palette,
         uint32_t *paletteLength,
         uint32_t **quantizedPixels,
         int kmeans)
{
   PixelList *hl[3];
   HashTable *h;
   BoxNode *root;
   uint32_t i;
   uint32_t *qp;
   uint32_t nPaletteEntries;

   uint32_t *avgDist;
   uint32_t **avgDistSortKey;
   Pixel *p;

#ifndef NO_OUTPUT
   uint32_t timer,timer2;
#endif

#ifndef NO_OUTPUT
   timer2=clock();
   printf ("create hash table..."); fflush(stdout); timer=clock();
#endif
   h=create_pixel_hash(pixelData,nPixels);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif
   if (!h) {
      goto error_0;
   }

#ifndef NO_OUTPUT
   printf ("create lists from hash table..."); fflush(stdout); timer=clock();
#endif
   hl[0]=hl[1]=hl[2]=NULL;
   hashtable_foreach(h,hash_to_list,hl);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

   if (!hl[0]) {
      goto error_1;
   }

#ifndef NO_OUTPUT
   printf ("mergesort lists..."); fflush(stdout); timer=clock();
#endif
   for(i=0;i<3;i++) {
      hl[i]=mergesort_pixels(hl[i],i);
   }
#ifdef TEST_MERGESORT
   if (!test_sorted(hl)) {
      printf ("bug in mergesort\n");
      goto error_1;
   }
#endif
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

#ifndef NO_OUTPUT
   printf ("median cut..."); fflush(stdout); timer=clock();
#endif
   root=median_cut(hl,nPixels,nQuantPixels);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif
   if (!root) {
      goto error_1;
   }
   nPaletteEntries=0;
#ifndef NO_OUTPUT
   printf ("median cut tree to hash table..."); fflush(stdout); timer=clock();
#endif
   annotate_hash_table(root,h,&nPaletteEntries);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif
#ifndef NO_OUTPUT
   printf ("compute palette...\n"); fflush(stdout); timer=clock();
#endif
   if (!compute_palette_from_median_cut(pixelData,nPixels,h,&p,nPaletteEntries)) {
      goto error_3;
   }
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

   free_box_tree(root);
   root=NULL;

   /* malloc check ok, using calloc for overflow */
   qp=calloc(nPixels, sizeof(uint32_t));
   if (!qp) { goto error_4; }

   if (nPaletteEntries > UINT32_MAX / nPaletteEntries )  {
       goto error_5;
   }
   /* malloc check ok, using calloc for overflow, check of n*n above */
   avgDist=calloc(nPaletteEntries*nPaletteEntries, sizeof(uint32_t));
   if (!avgDist) { goto error_5; }

   /* malloc check ok, using calloc for overflow, check of n*n above */
   avgDistSortKey=calloc(nPaletteEntries*nPaletteEntries, sizeof(uint32_t *));
   if (!avgDistSortKey) { goto error_6; }

   if (!build_distance_tables(avgDist,avgDistSortKey,p,nPaletteEntries)) {
      goto error_7;
   }

   if (!map_image_pixels_from_median_box(pixelData,nPixels,p,nPaletteEntries,h,avgDist,avgDistSortKey,qp)) {
      goto error_7;
   }

#ifdef TEST_NEAREST_NEIGHBOUR
#include <math.h>
   {
      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,pixelData[i],&paletteEntry)) {
            bestmatch=paletteEntry;
         } else {
            bestmatch=0;
            bestdist=
               _SQR(pixelData[i].c.r-p[0].c.r)+
               _SQR(pixelData[i].c.g-p[0].c.g)+
               _SQR(pixelData[i].c.b-p[0].c.b);
            for (j=1;j<nPaletteEntries;j++) {
               dist=
                  _SQR(pixelData[i].c.r-p[j].c.r)+
                  _SQR(pixelData[i].c.g-p[j].c.g)+
                  _SQR(pixelData[i].c.b-p[j].c.b);
               if (dist==bestdist && j==qp[i]) {
                  bestmatch=j;
               }
               if (dist<bestdist) {
                  bestdist=dist;
                  bestmatch=j;
               }
            }
            hashtable_insert(h2,pixelData[i],bestmatch);
         }
         if (qp[i]!=bestmatch ) {
            printf ("discrepancy in matching algorithms pixel %d [%d %d] %f %f\n",
                    i,qp[i],bestmatch,
                    sqrt((double)(_SQR(pixelData[i].c.r-p[qp[i]].c.r)+
                                  _SQR(pixelData[i].c.g-p[qp[i]].c.g)+
                                  _SQR(pixelData[i].c.b-p[qp[i]].c.b))),
                    sqrt((double)(_SQR(pixelData[i].c.r-p[bestmatch].c.r)+
                                  _SQR(pixelData[i].c.g-p[bestmatch].c.g)+
                                  _SQR(pixelData[i].c.b-p[bestmatch].c.b)))
                   );
         }
      }
      hashtable_free(h2);
   }
#endif
#ifndef NO_OUTPUT
   printf ("k means...\n"); fflush(stdout); timer=clock();
#endif
   if (kmeans) k_means(pixelData,nPixels,p,nPaletteEntries,qp,kmeans-1);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

   *quantizedPixels=qp;
   *palette=p;
   *paletteLength=nPaletteEntries;

#ifndef NO_OUTPUT
   printf ("cleanup..."); fflush(stdout); timer=clock();
#endif
   if (avgDist) free(avgDist);
   if (avgDistSortKey) free(avgDistSortKey);
   destroy_pixel_hash(h);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
   printf ("-----\ntotal time %f\n",(clock()-timer2)/(double)CLOCKS_PER_SEC);
#endif
   return 1;

error_7:
   if (avgDistSortKey) free(avgDistSortKey);
error_6:
   if (avgDist) free(avgDist);
error_5:
   if (qp) free(qp);
error_4:
   if (p) free(p);
error_3:
   if (root) free_box_tree(root);
error_1:
   destroy_pixel_hash(h);
error_0:
   *quantizedPixels=NULL;
   *paletteLength=0;
   *palette=NULL;
   return 0;
}

typedef struct {
   Pixel new;
   Pixel furthest;
   uint32_t furthestDistance;
   int secondPixel;
} DistanceData;

static void
compute_distances(const HashTable *h, const Pixel pixel, uint32_t *dist, void *u)
{
   DistanceData *data=(DistanceData *)u;
   uint32_t oldDist=*dist;
   uint32_t newDist;
   newDist=_DISTSQR(&(data->new),&pixel);
   if (data->secondPixel || newDist<oldDist) {
      *dist=newDist;
      oldDist=newDist;
   }
   if (oldDist>data->furthestDistance) {
      data->furthestDistance=oldDist;
      data->furthest.v=pixel.v;
   }
}

int
quantize2(Pixel *pixelData,
          uint32_t nPixels,
          uint32_t nQuantPixels,
          Pixel **palette,
          uint32_t *paletteLength,
          uint32_t **quantizedPixels,
          int kmeans)
{
   HashTable *h;
   uint32_t i;
   uint32_t mean[3];
   Pixel *p;
   DistanceData data;

   uint32_t *qp;
   uint32_t *avgDist;
   uint32_t **avgDistSortKey;

   /* malloc check ok, using calloc */
   p=calloc(nQuantPixels, sizeof(Pixel));
   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,pixelData[i],0xffffffff);
      mean[0]+=pixelData[i].c.r;
      mean[1]+=pixelData[i].c.g;
      mean[2]+=pixelData[i].c.b;
   }
   data.new.c.r=(int)(.5+(double)mean[0]/(double)nPixels);
   data.new.c.g=(int)(.5+(double)mean[1]/(double)nPixels);
   data.new.c.b=(int)(.5+(double)mean[2]/(double)nPixels);
   for (i=0;i<nQuantPixels;i++) {
      data.furthestDistance=0;
      data.secondPixel=(i==1)?1:0;
      hashtable_foreach_update(h,compute_distances,&data);
      p[i].v=data.furthest.v;
      data.new.v=data.furthest.v;
   }
   hashtable_free(h);

   /* malloc check ok, using calloc */
   qp=calloc(nPixels, sizeof(uint32_t));
   if (!qp) { goto error_1; }

   if (nQuantPixels > UINT32_MAX / nQuantPixels ) {
       goto error_2;
   }

   /* malloc check ok, using calloc for overflow, check of n*n above */
   avgDist=calloc(nQuantPixels*nQuantPixels, sizeof(uint32_t));
   if (!avgDist) { goto error_2; }

   /* malloc check ok, using calloc for overflow, check of n*n above */
   avgDistSortKey=calloc(nQuantPixels*nQuantPixels, sizeof(uint32_t *));
   if (!avgDistSortKey) { goto error_3; }

   if (!build_distance_tables(avgDist,avgDistSortKey,p,nQuantPixels)) {
      goto error_4;
   }

   if (!map_image_pixels(pixelData,nPixels,p,nQuantPixels,avgDist,avgDistSortKey,qp)) {
      goto error_4;
   }
   if (kmeans) k_means(pixelData,nPixels,p,nQuantPixels,qp,kmeans-1);

   *paletteLength=nQuantPixels;
   *palette=p;
   *quantizedPixels=qp;
   free(avgDistSortKey);
   free(avgDist);
   return 1;

error_4:
   free(avgDistSortKey);
error_3:
   free(avgDist);
error_2:
   free(qp);
error_1:
   free(p);
   return 0;
}

Imaging
ImagingQuantize(Imaging im, int colors, int mode, int kmeans)
{
    int i, j;
    int x, y, v;
    UINT8* pp;
    Pixel* p;
    Pixel* palette;
    uint32_t paletteLength;
    int result;
    uint32_t* newData;
    Imaging imOut;
    int withAlpha = 0;
    ImagingSectionCookie cookie;

    if (!im)
        return ImagingError_ModeError();
    if (colors < 1 || colors > 256)
        /* FIXME: for colors > 256, consider returning an RGB image
           instead (see @PIL205) */
        return (Imaging) ImagingError_ValueError("bad number of colors");

    if (strcmp(im->mode, "L") != 0 && strcmp(im->mode, "P") != 0 &&
        strcmp(im->mode, "RGB") != 0 && strcmp(im->mode, "RGBA") !=0)
        return ImagingError_ModeError();

    /* only octree and imagequant supports RGBA */
    if (!strcmp(im->mode, "RGBA") && mode != 2 && mode != 3)
       return ImagingError_ModeError();

    if (im->xsize > INT_MAX / im->ysize) {
        return ImagingError_MemoryError();
    }
    /* malloc check ok, using calloc for final overflow, x*y above */
    p = calloc(im->xsize * im->ysize, sizeof(Pixel));
    if (!p)
        return ImagingError_MemoryError();

    /* collect statistics */

    /* FIXME: maybe we could load the hash tables directly from the
       image data? */

    if (!strcmp(im->mode, "L")) {
        /* greyscale */

        /* FIXME: converting a "L" image to "P" with 256 colors
           should be done by a simple copy... */

        for (i = y = 0; y < im->ysize; y++)
            for (x = 0; x < im->xsize; x++, i++) {
                p[i].c.r = p[i].c.g = p[i].c.b = im->image8[y][x];
                p[i].c.a = 255;
            }

    } else if (!strcmp(im->mode, "P")) {
        /* palette */

        pp = im->palette->palette;

        for (i = y = 0; y < im->ysize; y++)
            for (x = 0; x < im->xsize; x++, i++) {
                v = im->image8[y][x];
                p[i].c.r = pp[v*4+0];
                p[i].c.g = pp[v*4+1];
                p[i].c.b = pp[v*4+2];
                p[i].c.a = pp[v*4+3];
            }

    } else if (!strcmp(im->mode, "RGB") || !strcmp(im->mode, "RGBA")) {
        /* true colour */

        for (i = y = 0; y < im->ysize; y++)
            for (x = 0; x < im->xsize; x++, i++)
                p[i].v = im->image32[y][x];

    } else {
        free(p);
        return (Imaging) ImagingError_ValueError("internal error");
    }

    ImagingSectionEnter(&cookie);

    switch (mode) {
    case 0:
        /* median cut */
        result = quantize(
            p,
            im->xsize*im->ysize,
            colors,
            &palette,
            &paletteLength,
            &newData,
            kmeans
            );
        break;
    case 1:
        /* maximum coverage */
        result = quantize2(
            p,
            im->xsize*im->ysize,
            colors,
            &palette,
            &paletteLength,
            &newData,
            kmeans
            );
        break;
    case 2:
        if (!strcmp(im->mode, "RGBA")) {
            withAlpha = 1;
        }
        result = quantize_octree(
            p,
            im->xsize*im->ysize,
            colors,
            &palette,
            &paletteLength,
            &newData,
            withAlpha
            );
        break;
    case 3:
#ifdef HAVE_LIBIMAGEQUANT
        if (!strcmp(im->mode, "RGBA")) {
            withAlpha = 1;
        }
        result = quantize_pngquant(
            p,
            im->xsize,
            im->ysize,
            colors,
            &palette,
            &paletteLength,
            &newData,
            withAlpha
            );
#else
        result = -1;
#endif
        break;
    default:
        result = 0;
        break;
    }

    free(p);
    ImagingSectionLeave(&cookie);

    if (result > 0) {
        imOut = ImagingNewDirty("P", im->xsize, im->ysize);
        ImagingSectionEnter(&cookie);

        for (i = y = 0; y < im->ysize; y++)
            for (x = 0; x < im->xsize; x++)
                imOut->image8[y][x] = (unsigned char) newData[i++];

        free(newData);

        pp = imOut->palette->palette;

        for (i = j = 0; i < (int) paletteLength; i++) {
            *pp++ = palette[i].c.r;
            *pp++ = palette[i].c.g;
            *pp++ = palette[i].c.b;
            if (withAlpha) {
               *pp++ = palette[i].c.a;
            } else {
               *pp++ = 255;
            }
        }
        for (; i < 256; i++) {
            *pp++ = 0;
            *pp++ = 0;
            *pp++ = 0;
            *pp++ = 255;
        }

        if (withAlpha) {
            strcpy(imOut->palette->mode, "RGBA");
        }

        free(palette);
        ImagingSectionLeave(&cookie);

        return imOut;

    } else {

        if (result == -1) {
            return (Imaging) ImagingError_ValueError(
                "dependency required by this method was not "
                "enabled at compile time");
        }

        return (Imaging) ImagingError_ValueError("quantization error");

    }
}