palcreate.c File Reference

#include "palcreate.h"
#include "tsc.h"
#include "paloptimize.h"
#include "ram.h"
#include "yuv.h"
#include "mempool.h"
#include "utility.h"
#include <stdlib.h>
#include <assert.h>

Go to the source code of this file.

Compounds
struct	octNode
Defines
#define	allocate(ptr)   ptr = geRam_AllocateClear(sizeof(*ptr))
#define	clear(ptr)   memset(ptr,0,sizeof(*ptr))
#define	square(x)   ((x)*(x))
#define	RGBbits(R, G, B, bits)   (((((R)>>(bits))&1)<<2) + ((((G)>>(bits))&1)<<1) + (((B)>>((bits)))&1))
#define	RADIX_SIZE   1024
Typedefs
typedef octNode	octNode
Functions
geBitmap_Palette *	createPaletteGood (const geBitmap_Info *Info, const void *Bits)
geBitmap_Palette *	createPaletteFast (const geBitmap_Info *Info, const void *Bits)
void	setCreatePaletteFunc (paletteCreater func)
geBitmap_Palette *	createPalette (const geBitmap_Info *Info, const void *Bits)
geBitmap_Palette *	createPaletteFromBitmap (const geBitmap *Bitmap, geBoolean Optimize)
int	createOctTree (octNode *root, const geBitmap_Info *Info, const void *Bits, geBoolean doYUV)
geBitmap_Palette *	createPaletteGoodSub (const geBitmap_Info *Info, const void *Bits)
void	addOctNode (octNode *root, int R, int G, int B, int *nLeavesPtr)
void	gatherLeaves (octNode *node, octNode ***leavesPtrPtr, int minCount)
void	gatherLeavesCutting (octNode *node, octNode ***leavesPtrPtr)
int	leafCompareCount (const void *a, const void *b)
int	leafCompareCost (const void *a, const void *b)
int	findClosest (int R, int G, int B, uint8 *palette, int palEntries, int *foundPalPtr)
void	computeOctRGBs (octNode *node)
void	computeCutCosts (octNode *node)
void	readLeavesToPal (octNode **leaves, int gotLeaves, uint8 *palette, int palEntries)
void	insertRadix (octNode *radix, octNode *leaf)
void	PalCreate_Start (void)
void	PalCreate_Stop (void)
Variables
paletteCreater	myPaletteCreater = createPaletteGood
MemPool *	octNodePool = NULL
int	PoolRefs = 0

---

Define Documentation

#define allocate (  ptr   )     ptr = geRam_AllocateClear(sizeof(*ptr))

Definition at line 96 of file palcreate.c.

#define clear (  ptr   )     memset(ptr,0,sizeof(*ptr))

Definition at line 97 of file palcreate.c.

#define RADIX_SIZE   1024

Definition at line 192 of file palcreate.c. Referenced by createPaletteGoodSub(), and insertRadix().

#define RGBbits (  R, G, B, bits   )     (((((R)>>(bits))&1)<<2) + ((((G)>>(bits))&1)<<1) + (((B)>>((bits)))&1))

Definition at line 190 of file palcreate.c. Referenced by addOctNode().

#define square (  x   )     ((x)*(x))

Definition at line 188 of file palcreate.c. Referenced by computeCutCosts(), and findClosest().

---

Typedef Documentation

typedef struct octNode octNode

Definition at line 175 of file palcreate.c. Referenced by addOctNode(), closestPal(), closestPalInlineRGB(), computeOctRGBs(), createPaletteFast(), createPaletteGoodSub(), gatherLeavesCutting(), insertRadix(), leafCompareCost(), leafCompareCount(), PalCreate_Start(), Palettize_Start(), and readLeavesToPal().

---

Function Documentation

void addOctNode (  octNode *  root, int  R, int  G, int  B, int *  nLeavesPtr )

Definition at line 462 of file palcreate.c. References octNode::B, B, octNode::count, octNode::G, G, octNode::kids, MemPool_GetHunk(), octNode::nKids, octNode, octNodePool, octNode::parent, octNode::R, R, and RGBbits. { int idx; int bits; octNode *node; node = root; for(bits=7;bits>=0;bits--) { idx = RGBbits(R,G,B,bits); if ( ! node->kids[idx] ) { node->nKids ++; node->kids[idx] = MemPool_GetHunk(octNodePool); node->kids[idx]->parent = node; } node->count ++; node = node->kids[idx]; } if ( node->count == 0 ) (*nLeavesPtr)++; node->count ++; node->R = R; node->G = G; node->B = B; }

void computeCutCosts (  octNode *  node  )

Definition at line 563 of file palcreate.c. References octNode::B, octNode::count, octNode::cutCost, octNode::G, octNode::kids, octNode::nKids, octNode::parent, octNode::R, and square. Referenced by createPaletteGoodSub(). { assert(node->parent); node->cutCost = square(node->R - node->parent->R) + square(node->G - node->parent->G) + square(node->B - node->parent->B); node->cutCost *= node->count; if ( node->nKids > 0 ) { int i; for(i=0;i<8;i++) if ( node->kids[i] ) { computeCutCosts(node->kids[i]); node->cutCost += node->kids[i]->cutCost; } } }

void computeOctRGBs (  octNode *  node  )

Definition at line 583 of file palcreate.c. References octNode::B, B, octNode::count, octNode::G, G, octNode::kids, octNode::nKids, octNode, octNode::R, and R. Referenced by createPaletteGoodSub(). { if ( node->nKids > 0 ) { int R,G,B; int i; octNode *kid; R = G = B = 0; for(i=0;i<8;i++) if ( node->kids[i] ) computeOctRGBs(node->kids[i]); for(i=0;i<8;i++) { if ( kid = node->kids[i] ) { R += kid->count * kid->R; G += kid->count * kid->G; B += kid->count * kid->B; } } node->R = R / (node->count); node->G = G / (node->count); node->B = B / (node->count); } }

int createOctTree (  octNode *  root, const geBitmap_Info *  Info, const void *  Bits, geBoolean  doYUV )

Definition at line 643 of file palcreate.c. References A, addOctNode(), B, gePixelFormat_Operations::DecomposePixel, geBitmap_Info::Format, G, GE_FALSE, GE_PIXELFORMAT_24BIT_BGR, GE_PIXELFORMAT_24BIT_RGB, gePixelFormat, gePixelFormat_BytesPerPel(), gePixelFormat_Decomposer, gePixelFormat_GetOperations(), geBitmap_Info::Height, R, RGBb_to_YUVi(), RGBi_to_YUVi(), geBitmap_Info::Stride, uint16, uint32, uint8, geBitmap_Info::Width, and y. Referenced by createPaletteFast(), and createPaletteGoodSub(). { int nLeaves; int w,h,xtra,bpp,x,y; gePixelFormat Format; const gePixelFormat_Operations * ops; int R,G,B,A; gePixelFormat_Decomposer Decompose; assert(Bits); nLeaves = 0; Format = Info->Format; w = Info->Width; h = Info->Height; xtra = Info->Stride - Info->Width; bpp = gePixelFormat_BytesPerPel(Format); ops = gePixelFormat_GetOperations(Format); assert(ops); Decompose = ops->DecomposePixel; assert(Decompose); // pushTSC(); if ( doYUV ) { switch(bpp) { default: case 0: return GE_FALSE; case 1: { const uint8 *ptr; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { Decompose(*ptr++,&R,&G,&B,&A); RGBi_to_YUVi(R,G,B,&R,&G,&B); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } case 2: { const uint16 *ptr; uint32 R,G,B,A; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { Decompose(*ptr++,&R,&G,&B,&A); RGBi_to_YUVi(R,G,B,&R,&G,&B); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } case 3: { const uint8 *ptr; uint32 R,G,B,A,Pixel; ptr = Bits; xtra *= 3; switch(Format) { case GE_PIXELFORMAT_24BIT_RGB : for(y=h;y--;) { for(x=w;x--;) { RGBb_to_YUVi(ptr,&R,&G,&B); ptr += 3; addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; case GE_PIXELFORMAT_24BIT_BGR : for(y=h;y--;) { for(x=w;x--;) { B = *ptr++; G = *ptr++; R = *ptr++; RGBi_to_YUVi(R,G,B,&R,&G,&B); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; default: // can't get here now for(y=h;y--;) { for(x=w;x--;) { Pixel = (ptr[0]<<16) + (ptr[1]<<8) + ptr[2]; ptr += 3; Decompose(Pixel,&R,&G,&B,&A); RGBi_to_YUVi(R,G,B,&R,&G,&B); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } break; // Thanks Bobtree } case 4: { const uint32 *ptr; uint32 R,G,B,A; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { Decompose(*ptr++,&R,&G,&B,&A); RGBi_to_YUVi(R,G,B,&R,&G,&B); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } } } else { switch(bpp) { default: case 0: return GE_FALSE; case 1: { const uint8 *ptr; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { Decompose(*ptr++,&R,&G,&B,&A); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } case 2: { const uint16 *ptr; uint32 R,G,B,A; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { Decompose(*ptr++,&R,&G,&B,&A); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } case 3: { const uint8 *ptr; uint32 R,G,B,A,Pixel; ptr = Bits; xtra *= 3; switch(Format) { case GE_PIXELFORMAT_24BIT_RGB : for(y=h;y--;) { for(x=w;x--;) { R = *ptr++; G = *ptr++; B = *ptr++; addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; case GE_PIXELFORMAT_24BIT_BGR : for(y=h;y--;) { for(x=w;x--;) { B = *ptr++; G = *ptr++; R = *ptr++; addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; default: // can't get here now for(y=h;y--;) { for(x=w;x--;) { Pixel = (ptr[0]<<16) + (ptr[1]<<8) + ptr[2]; ptr += 3; Decompose(Pixel,&R,&G,&B,&A); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } break; // Thanks Bobtree } case 4: { const uint32 *ptr; uint32 R,G,B,A; ptr = Bits; for(y=h;y--;) { for(x=w;x--;) { Decompose(*ptr++,&R,&G,&B,&A); addOctNode(root,R,G,B,&nLeaves); } ptr += xtra; } break; } } } // showPopTSC("create Pal OctTree"); return nLeaves; }

geBitmap_Palette* createPalette (  const geBitmap_Info *  Info, const void *  Bits )

Definition at line 112 of file palcreate.c. References geBitmap_Info::Format, GE_PIXELFORMAT_8BIT_GRAY, GE_PIXELFORMAT_8BIT_PAL, geBitmap_Palette_Create(), geBitmap_Palette_SetData(), myPaletteCreater, NULL, geBitmap_Info::Palette, and uint8. Referenced by createPaletteFromBitmap(), and geBitmap_BlitData_Sub(). { assert(Info && Bits); switch(Info->Format) { case GE_PIXELFORMAT_8BIT_PAL : return Info->Palette; case GE_PIXELFORMAT_8BIT_GRAY : { geBitmap_Palette * Pal; uint8 GrayPal[256]; int i; Pal = geBitmap_Palette_Create(GE_PIXELFORMAT_8BIT_GRAY,256); if ( ! Pal ) return NULL; for(i=0;i<256;i++) GrayPal[i] = i; geBitmap_Palette_SetData(Pal,GrayPal,GE_PIXELFORMAT_8BIT_GRAY,256); return Pal; } default: return myPaletteCreater(Info,Bits); } }

geBitmap_Palette * createPaletteFast (  const geBitmap_Info *  Info, const void *  Bits )

Definition at line 237 of file palcreate.c. References createOctTree(), destroy, gatherLeaves(), GE_FALSE, GE_PIXELFORMAT_24BIT_RGB, geBitmap_Palette_Create(), geBitmap_Palette_SetData(), geRam_AllocateClear(), leafCompareCount(), MemPool_GetHunk(), MemPool_Reset(), NULL, octNode, octNodePool, pushTSC, readLeavesToPal(), showPopTSC, uint32, and uint8. Referenced by setCreatePaletteFunc(). { octNode * root; int nLeaves,minCount,gotLeaves; octNode ** leaves,**leavesPtr; uint8 palette[768]; int palEntries = 256; geBitmap_Palette * Pal; pushTSC(); // read the whole image into an octree // this is the only pass over the input plane MemPool_Reset(octNodePool); root = MemPool_GetHunk(octNodePool); assert(root); nLeaves = createOctTree(root,Info,Bits,GE_FALSE); leaves = geRam_AllocateClear(sizeof(octNode *)*nLeaves); assert(leaves); // gather leaves into a linear array // for speed we ignore leaves with a count lower than [x] gotLeaves = 0; for( minCount = 3; minCount >= 0 && gotLeaves < palEntries ; minCount-- ) { leavesPtr = leaves; gatherLeaves(root,&leavesPtr,minCount); gotLeaves = ((uint32)leavesPtr - (uint32)leaves)/sizeof(octNode *); } // sort the leaves by count qsort(leaves,gotLeaves,sizeof(octNode *),leafCompareCount); // read the sorted leaves in by count; we try to only read in leaves // that are farther than 'minDistance' from nodes already in the palette readLeavesToPal(leaves,gotLeaves,palette,palEntries); destroy(leaves); showPopTSC("createPalFast"); Pal = geBitmap_Palette_Create(GE_PIXELFORMAT_24BIT_RGB,palEntries); if ( ! Pal ) return NULL; if ( ! geBitmap_Palette_SetData(Pal,palette,GE_PIXELFORMAT_24BIT_RGB,palEntries) ) assert(0); return Pal; }

geBitmap_Palette* createPaletteFromBitmap (  const geBitmap *  Bitmap, geBoolean  Optimize )

Definition at line 135 of file palcreate.c. References createPalette(), GE_FALSE, GE_PIXELFORMAT_24BIT_RGB, geBitmap_GetBits(), geBitmap_GetInfo(), geBitmap_LockForRead(), geBitmap_Palette_GetData(), geBitmap_Palette_SetData(), geBitmap_UnLock(), NULL, paletteOptimize(), and uint8. Referenced by geBitmap_Palette_CreateFromBitmap(). { geBitmap * Lock; geBitmap_Info Info; const void * Bits; geBitmap_Palette * Pal; if ( ! geBitmap_GetInfo(Bitmap,&Info,NULL) ) return NULL; if ( ! geBitmap_LockForRead((geBitmap *)Bitmap,&Lock,0,0,GE_PIXELFORMAT_24BIT_RGB,GE_FALSE,0) ) return NULL; if ( ! geBitmap_GetInfo(Lock,&Info,NULL) ) return NULL; Bits = (const void *) geBitmap_GetBits(Lock); Pal = createPalette(&Info,Bits); if ( Pal && Optimize ) { uint8 paldata[768]; if ( ! geBitmap_Palette_GetData(Pal,paldata,GE_PIXELFORMAT_24BIT_RGB,256) ) assert(0); paletteOptimize(&Info,Bits,paldata,256,0); if ( ! geBitmap_Palette_SetData(Pal,paldata,GE_PIXELFORMAT_24BIT_RGB,256) ) assert(0); } geBitmap_UnLock(Lock); return Pal; }

geBitmap_Palette * createPaletteGood (  const geBitmap_Info *  Info, const void *  Bits )

Definition at line 293 of file palcreate.c. References createPaletteGoodSub(). Referenced by setCreatePaletteFunc(). { return createPaletteGoodSub(Info,Bits); }

geBitmap_Palette * createPaletteGoodSub (  const geBitmap_Info *  Info, const void *  Bits )

Definition at line 298 of file palcreate.c. References octNode::B, computeCutCosts(), computeOctRGBs(), createOctTree(), destroy, octNode::G, gatherLeavesCutting(), GE_PIXELFORMAT_24BIT_RGB, GE_TRUE, geBitmap_Palette_Create(), geBitmap_Palette_SetData(), geRam_AllocateClear(), insertRadix(), MemPool_GetHunk(), MemPool_Reset(), octNode::next, octNode::nKids, NULL, octNode, octNodePool, octNode::parent, octNode::prev, pushTSC, octNode::R, RADIX_SIZE, readLeavesToPal(), showPopTSC, uint32, uint8, and YUVb_to_RGBb_line(). Referenced by createPaletteGood(). { octNode * root; int nLeaves,i,gotLeaves,radixN; octNode ** leaves,**leavesPtr; octNode *leaf,*node; octNode *radix; uint8 palette[768],*palPtr; int palEntries = 256; geBitmap_Palette * Pal; pushTSC(); // read the whole image into an octree // this is the only pass over the input plane MemPool_Reset(octNodePool); root = MemPool_GetHunk(octNodePool); assert(root); nLeaves = createOctTree(root,Info,Bits,GE_TRUE); leaves = geRam_AllocateClear(sizeof(octNode *)*nLeaves); assert(leaves); computeOctRGBs(root); root->parent = root; computeCutCosts(root); root->parent = NULL; // gather leaves into a linear array // for speed we ignore leaves with a count lower than [x] leavesPtr = leaves; gatherLeavesCutting(root,&leavesPtr); gotLeaves = ((uint32)leavesPtr - (uint32)leaves)/sizeof(octNode *); // if gotLeaves < palEntries, just exit asap if ( gotLeaves < palEntries ) { readLeavesToPal(leaves,gotLeaves,palette,palEntries); goto done; } // sort the leaves by cutCost // radix sort instead of qsort radix = geRam_AllocateClear(sizeof(octNode)*RADIX_SIZE); assert(radix); for(i=0;i<RADIX_SIZE;i++) radix[i].next = radix[i].prev = &radix[i]; for(i=0;i<gotLeaves;i++) insertRadix(radix,leaves[i]); // keep cutting the tail radixN = 0; while(gotLeaves > palEntries) { while( (leaf = radix[radixN].next) == &(radix[radixN]) ) { radixN++; assert( radixN < RADIX_SIZE ); } // cut it leaf->prev->next = leaf->next; leaf->next->prev = leaf->prev; node = leaf->parent; assert(node); node->nKids --; // might turn its parent into a leaf; // if so, add it to the list // nKids no longer corresponds to the actual number of active kids if ( node->nKids == 0 ) insertRadix(radix,node); else gotLeaves--; } // read the sorted leaves in by count; we try to only read in leaves // that are farther than 'minDistance' from nodes already in the palette palPtr = palette; radixN = RADIX_SIZE-1; leaf = radix[radixN].prev; for(i=0;i<palEntries && radixN>0;i++) { *palPtr++ = leaf->R; *palPtr++ = leaf->G; *palPtr++ = leaf->B; leaf = leaf->prev; while ( leaf == &(radix[radixN]) ) { radixN --; if ( ! radixN ) break; leaf = radix[radixN].prev; } } destroy(radix); done: destroy(leaves); showPopTSC("createPalGood"); YUVb_to_RGBb_line(palette,palette,palEntries); Pal = geBitmap_Palette_Create(GE_PIXELFORMAT_24BIT_RGB,palEntries); if ( ! Pal ) return NULL; if ( ! geBitmap_Palette_SetData(Pal,palette,GE_PIXELFORMAT_24BIT_RGB,palEntries) ) assert(0); return Pal; }

int findClosest (  int  R, int  G, int  B, uint8 *  palette, int  palEntries, int *  foundPalPtr )

Definition at line 444 of file palcreate.c. References B, G, R, and square. Referenced by readLeavesToPal(). { int i,d,bestD,bestP; bestD = 99999999; bestP = -1; for(i=palEntries;i--;) { d = square(R - palette[0]) + square(G - palette[1]) + square(B - palette[2]); palette += 3; if ( d < bestD ) { bestD = d; bestP = i; } } if ( foundPalPtr ) *foundPalPtr = bestP; return bestD; }

void gatherLeaves (  octNode *  node, octNode ***  leavesPtrPtr, int  minCount )

Definition at line 488 of file palcreate.c. References octNode::count, octNode::kids, and octNode::nKids. Referenced by createPaletteFast(). { if ( node->count <= minCount ) return; if ( node->nKids == 0 ) { *(*leavesPtrPtr)++ = node; } else { int i; for(i=0;i<8;i++) { if ( node->kids[i] ) gatherLeaves(node->kids[i],leavesPtrPtr,minCount); } } }

void gatherLeavesCutting (  octNode *  node, octNode ***  leavesPtrPtr )

Definition at line 505 of file palcreate.c. References octNode::count, octNode::cutCost, octNode::kids, octNode::nKids, NULL, octNode, and octNode::parent. Referenced by createPaletteGoodSub(). { if ( node->nKids > 0 ) { int i; for(i=0;i<8;i++) { if ( node->kids[i] ) { if ( node->kids[i]->count <= 1 || node->kids[i]->cutCost <= 1 ) { //freeOctNodes(node->kids[i]); node->kids[i] = NULL; node->nKids--; } else { gatherLeavesCutting(node->kids[i],leavesPtrPtr); if ( node->kids[i]->nKids == 1 ) { octNode *kid; int j; kid = node->kids[i]; for(j=0;j<8;j++) if ( kid->kids[j] ) node->kids[i] = kid->kids[j]; assert( node->kids[i] != kid ); node->kids[i]->cutCost = kid->cutCost; //destroy(kid); node->kids[i]->parent = node; } } } } } if ( node->nKids == 0 ) { *(*leavesPtrPtr)++ = node; } }

void insertRadix (  octNode *  radix, octNode *  leaf )

Definition at line 424 of file palcreate.c. References octNode::cutCost, octNode::next, octNode, octNode::prev, and RADIX_SIZE. Referenced by createPaletteGoodSub(). { octNode *insertAt; if ( leaf->cutCost >= RADIX_SIZE ) { octNode * head; insertAt = head = & radix[RADIX_SIZE-1]; while(insertAt->cutCost < leaf->cutCost && insertAt->next != head ) insertAt = insertAt->next; } else insertAt = & radix[leaf->cutCost]; leaf->next = insertAt->next; leaf->next->prev = leaf; insertAt->next = leaf; insertAt->next->prev = insertAt; }

int leafCompareCost (  const void *  a, const void *  b )

Definition at line 555 of file palcreate.c. References octNode::cutCost, and octNode. { octNode *na,*nb; na = *((octNode **)a); nb = *((octNode **)b); return (nb->cutCost) - (na->cutCost); }

int leafCompareCount (  const void *  a, const void *  b )

Definition at line 548 of file palcreate.c. References octNode::count, and octNode. Referenced by createPaletteFast(). { octNode *na,*nb; na = *((octNode **)a); nb = *((octNode **)b); return (nb->count) - (na->count); }

void PalCreate_Start (  void   )

Definition at line 212 of file palcreate.c. References MemPool_Create(), octNode, octNodePool, and PoolRefs. Referenced by geBitmap_Start(). { if ( PoolRefs == 0 ) { int num; // we do addOctNode, one for each unique color // make the poolhunks 64k num = (1<<16) / sizeof(octNode); octNodePool = MemPool_Create(sizeof(octNode),num,num); assert(octNodePool); } PoolRefs ++; }

void PalCreate_Stop (  void   )

Definition at line 226 of file palcreate.c. References MemPool_Destroy(), octNodePool, and PoolRefs. Referenced by geBitmap_Stop(). { PoolRefs --; if ( PoolRefs == 0 ) { MemPool_Destroy(&octNodePool); } }

void readLeavesToPal (  octNode **  leaves, int  gotLeaves, uint8 *  palette, int  palEntries )

Definition at line 609 of file palcreate.c. References B, findClosest(), G, NULL, octNode, R, and uint8. Referenced by createPaletteFast(), and createPaletteGoodSub(). { octNode **leavesPtr; uint8 *palPtr; int R,G,B; int i,palGot; int distance,minDistance; palPtr = palette; palGot = 0; for(minDistance=256;minDistance>=0 && palGot < palEntries;minDistance>>=1) { leavesPtr = leaves; for(i=0;i<gotLeaves;i++) { R = (*leavesPtr)->R; G = (*leavesPtr)->G; B = (*leavesPtr)->B; leavesPtr++; distance = findClosest(R,G,B,palette,palGot,NULL); if ( distance >= minDistance ) { *palPtr++ = R; *palPtr++ = G; *palPtr++ = B; palGot ++; if ( palGot == palEntries ) break; } } } }

void setCreatePaletteFunc (  paletteCreater  func  )

Definition at line 106 of file palcreate.c. References createPaletteFast(), createPaletteGood(), and myPaletteCreater. { assert( func == createPaletteGood || func == createPaletteFast ); myPaletteCreater = func; }

---

Variable Documentation

paletteCreater myPaletteCreater = createPaletteGood

Definition at line 104 of file palcreate.c. Referenced by createPalette(), and setCreatePaletteFunc().

MemPool* octNodePool = NULL [static]

Definition at line 209 of file palcreate.c. Referenced by addOctNode(), createPaletteFast(), createPaletteGoodSub(), PalCreate_Start(), and PalCreate_Stop().

int PoolRefs = 0 [static]

Definition at line 210 of file palcreate.c. Referenced by PalCreate_Start(), and PalCreate_Stop().

---