1 /*****************************************************************************
2
3 quantize.c - quantize a high resolution image into lower one
4
5 Based on: "Color Image Quantization for frame buffer Display", by
6 Paul Heckbert SIGGRAPH 1982 page 297-307.
7
8 This doesn't really belong in the core library, was undocumented,
9 and was removed in 4.2. Then it turned out some client apps were
10 actually using it, so it was restored in 5.0.
11
12 SPDX-License-Identifier: MIT
13
14 ******************************************************************************/
15
16 #include <stdio.h>
17 #include <stdlib.h>
18
19 #include "gif_lib.h"
20 #include "gif_lib_private.h"
21
22 #define ABS(x) ((x) > 0 ? (x) : (-(x)))
23
24 #define COLOR_ARRAY_SIZE 32768
25 #define BITS_PER_PRIM_COLOR 5
26 #define MAX_PRIM_COLOR 0x1f
27
28 static int SortRGBAxis;
29
30 typedef struct QuantizedColorType {
31 GifByteType RGB[3];
32 GifByteType NewColorIndex;
33 long Count;
34 struct QuantizedColorType *Pnext;
35 } QuantizedColorType;
36
37 typedef struct NewColorMapType {
38 GifByteType RGBMin[3], RGBWidth[3];
39 unsigned int
40 NumEntries; /* # of QuantizedColorType in linked list below */
41 unsigned long Count; /* Total number of pixels in all the entries */
42 QuantizedColorType *QuantizedColors;
43 } NewColorMapType;
44
45 static int SubdivColorMap(NewColorMapType *NewColorSubdiv,
46 unsigned int ColorMapSize,
47 unsigned int *NewColorMapSize);
48 static int SortCmpRtn(const void *Entry1, const void *Entry2);
49
50 /******************************************************************************
51 Quantize high resolution image into lower one. Input image consists of a
52 2D array for each of the RGB colors with size Width by Height. There is no
53 Color map for the input. Output is a quantized image with 2D array of
54 indexes into the output color map.
55 Note input image can be 24 bits at the most (8 for red/green/blue) and
56 the output has 256 colors at the most (256 entries in the color map.).
57 ColorMapSize specifies size of color map up to 256 and will be updated to
58 real size before returning.
59 Also non of the parameter are allocated by this routine.
60 This function returns GIF_OK if successful, GIF_ERROR otherwise.
61 ******************************************************************************/
GifQuantizeBuffer(unsigned int Width,unsigned int Height,int * ColorMapSize,const GifByteType * RedInput,const GifByteType * GreenInput,const GifByteType * BlueInput,GifByteType * OutputBuffer,GifColorType * OutputColorMap)62 int GifQuantizeBuffer(unsigned int Width, unsigned int Height,
63 int *ColorMapSize, const GifByteType *RedInput,
64 const GifByteType *GreenInput,
65 const GifByteType *BlueInput, GifByteType *OutputBuffer,
66 GifColorType *OutputColorMap) {
67
68 unsigned int Index, NumOfEntries;
69 int i, j, MaxRGBError[3];
70 unsigned int NewColorMapSize;
71 long Red, Green, Blue;
72 NewColorMapType NewColorSubdiv[256];
73 QuantizedColorType *ColorArrayEntries, *QuantizedColor;
74
75 ColorArrayEntries = (QuantizedColorType *)malloc(
76 sizeof(QuantizedColorType) * COLOR_ARRAY_SIZE);
77 if (ColorArrayEntries == NULL) {
78 return GIF_ERROR;
79 }
80
81 for (i = 0; i < COLOR_ARRAY_SIZE; i++) {
82 ColorArrayEntries[i].RGB[0] = i >> (2 * BITS_PER_PRIM_COLOR);
83 ColorArrayEntries[i].RGB[1] =
84 (i >> BITS_PER_PRIM_COLOR) & MAX_PRIM_COLOR;
85 ColorArrayEntries[i].RGB[2] = i & MAX_PRIM_COLOR;
86 ColorArrayEntries[i].Count = 0;
87 }
88
89 /* Sample the colors and their distribution: */
90 for (i = 0; i < (int)(Width * Height); i++) {
91 Index = ((RedInput[i] >> (8 - BITS_PER_PRIM_COLOR))
92 << (2 * BITS_PER_PRIM_COLOR)) +
93 ((GreenInput[i] >> (8 - BITS_PER_PRIM_COLOR))
94 << BITS_PER_PRIM_COLOR) +
95 (BlueInput[i] >> (8 - BITS_PER_PRIM_COLOR));
96 ColorArrayEntries[Index].Count++;
97 }
98
99 /* Put all the colors in the first entry of the color map, and call the
100 * recursive subdivision process. */
101 for (i = 0; i < 256; i++) {
102 NewColorSubdiv[i].QuantizedColors = NULL;
103 NewColorSubdiv[i].Count = NewColorSubdiv[i].NumEntries = 0;
104 for (j = 0; j < 3; j++) {
105 NewColorSubdiv[i].RGBMin[j] = 0;
106 NewColorSubdiv[i].RGBWidth[j] = 255;
107 }
108 }
109
110 /* Find the non empty entries in the color table and chain them: */
111 for (i = 0; i < COLOR_ARRAY_SIZE; i++) {
112 if (ColorArrayEntries[i].Count > 0) {
113 break;
114 }
115 }
116 QuantizedColor = NewColorSubdiv[0].QuantizedColors =
117 &ColorArrayEntries[i];
118 NumOfEntries = 1;
119 while (++i < COLOR_ARRAY_SIZE) {
120 if (ColorArrayEntries[i].Count > 0) {
121 QuantizedColor->Pnext = &ColorArrayEntries[i];
122 QuantizedColor = &ColorArrayEntries[i];
123 NumOfEntries++;
124 }
125 }
126 QuantizedColor->Pnext = NULL;
127
128 NewColorSubdiv[0].NumEntries =
129 NumOfEntries; /* Different sampled colors */
130 NewColorSubdiv[0].Count = ((long)Width) * Height; /* Pixels */
131 NewColorMapSize = 1;
132 if (SubdivColorMap(NewColorSubdiv, *ColorMapSize, &NewColorMapSize) !=
133 GIF_OK) {
134 free((char *)ColorArrayEntries);
135 return GIF_ERROR;
136 }
137 if (NewColorMapSize < *ColorMapSize) {
138 /* And clear rest of color map: */
139 for (i = NewColorMapSize; i < *ColorMapSize; i++) {
140 OutputColorMap[i].Red = OutputColorMap[i].Green =
141 OutputColorMap[i].Blue = 0;
142 }
143 }
144
145 /* Average the colors in each entry to be the color to be used in the
146 * output color map, and plug it into the output color map itself. */
147 for (i = 0; i < NewColorMapSize; i++) {
148 if ((j = NewColorSubdiv[i].NumEntries) > 0) {
149 QuantizedColor = NewColorSubdiv[i].QuantizedColors;
150 Red = Green = Blue = 0;
151 while (QuantizedColor) {
152 QuantizedColor->NewColorIndex = i;
153 Red += QuantizedColor->RGB[0];
154 Green += QuantizedColor->RGB[1];
155 Blue += QuantizedColor->RGB[2];
156 QuantizedColor = QuantizedColor->Pnext;
157 }
158 OutputColorMap[i].Red =
159 (Red << (8 - BITS_PER_PRIM_COLOR)) / j;
160 OutputColorMap[i].Green =
161 (Green << (8 - BITS_PER_PRIM_COLOR)) / j;
162 OutputColorMap[i].Blue =
163 (Blue << (8 - BITS_PER_PRIM_COLOR)) / j;
164 }
165 }
166
167 /* Finally scan the input buffer again and put the mapped index in the
168 * output buffer. */
169 MaxRGBError[0] = MaxRGBError[1] = MaxRGBError[2] = 0;
170 for (i = 0; i < (int)(Width * Height); i++) {
171 Index = ((RedInput[i] >> (8 - BITS_PER_PRIM_COLOR))
172 << (2 * BITS_PER_PRIM_COLOR)) +
173 ((GreenInput[i] >> (8 - BITS_PER_PRIM_COLOR))
174 << BITS_PER_PRIM_COLOR) +
175 (BlueInput[i] >> (8 - BITS_PER_PRIM_COLOR));
176 Index = ColorArrayEntries[Index].NewColorIndex;
177 OutputBuffer[i] = Index;
178 if (MaxRGBError[0] <
179 ABS(OutputColorMap[Index].Red - RedInput[i])) {
180 MaxRGBError[0] =
181 ABS(OutputColorMap[Index].Red - RedInput[i]);
182 }
183 if (MaxRGBError[1] <
184 ABS(OutputColorMap[Index].Green - GreenInput[i])) {
185 MaxRGBError[1] =
186 ABS(OutputColorMap[Index].Green - GreenInput[i]);
187 }
188 if (MaxRGBError[2] <
189 ABS(OutputColorMap[Index].Blue - BlueInput[i])) {
190 MaxRGBError[2] =
191 ABS(OutputColorMap[Index].Blue - BlueInput[i]);
192 }
193 }
194
195 #ifdef DEBUG
196 fprintf(stderr,
197 "Quantization L(0) errors: Red = %d, Green = %d, Blue = %d.\n",
198 MaxRGBError[0], MaxRGBError[1], MaxRGBError[2]);
199 #endif /* DEBUG */
200
201 free((char *)ColorArrayEntries);
202
203 *ColorMapSize = NewColorMapSize;
204
205 return GIF_OK;
206 }
207
208 /******************************************************************************
209 Routine to subdivide the RGB space recursively using median cut in each
210 axes alternatingly until ColorMapSize different cubes exists.
211 The biggest cube in one dimension is subdivide unless it has only one entry.
212 Returns GIF_ERROR if failed, otherwise GIF_OK.
213 *******************************************************************************/
SubdivColorMap(NewColorMapType * NewColorSubdiv,unsigned int ColorMapSize,unsigned int * NewColorMapSize)214 static int SubdivColorMap(NewColorMapType *NewColorSubdiv,
215 unsigned int ColorMapSize,
216 unsigned int *NewColorMapSize) {
217
218 unsigned int i, j, Index = 0;
219 QuantizedColorType *QuantizedColor, **SortArray;
220
221 while (ColorMapSize > *NewColorMapSize) {
222 /* Find candidate for subdivision: */
223 long Sum, Count;
224 int MaxSize = -1;
225 unsigned int NumEntries, MinColor, MaxColor;
226 for (i = 0; i < *NewColorMapSize; i++) {
227 for (j = 0; j < 3; j++) {
228 if ((((int)NewColorSubdiv[i].RGBWidth[j]) >
229 MaxSize) &&
230 (NewColorSubdiv[i].NumEntries > 1)) {
231 MaxSize = NewColorSubdiv[i].RGBWidth[j];
232 Index = i;
233 SortRGBAxis = j;
234 }
235 }
236 }
237
238 if (MaxSize == -1) {
239 return GIF_OK;
240 }
241
242 /* Split the entry Index into two along the axis SortRGBAxis: */
243
244 /* Sort all elements in that entry along the given axis and
245 * split at the median. */
246 SortArray = (QuantizedColorType **)malloc(
247 sizeof(QuantizedColorType *) *
248 NewColorSubdiv[Index].NumEntries);
249 if (SortArray == NULL) {
250 return GIF_ERROR;
251 }
252 for (j = 0,
253 QuantizedColor = NewColorSubdiv[Index].QuantizedColors;
254 j < NewColorSubdiv[Index].NumEntries &&
255 QuantizedColor != NULL;
256 j++, QuantizedColor = QuantizedColor->Pnext) {
257 SortArray[j] = QuantizedColor;
258 }
259
260 /*
261 * Because qsort isn't stable, this can produce differing
262 * results for the order of tuples depending on platform
263 * details of how qsort() is implemented.
264 *
265 * We mitigate this problem by sorting on all three axes rather
266 * than only the one specied by SortRGBAxis; that way the
267 * instability can only become an issue if there are multiple
268 * color indices referring to identical RGB tuples. Older
269 * versions of this sorted on only the one axis.
270 */
271 qsort(SortArray, NewColorSubdiv[Index].NumEntries,
272 sizeof(QuantizedColorType *), SortCmpRtn);
273
274 /* Relink the sorted list into one: */
275 for (j = 0; j < NewColorSubdiv[Index].NumEntries - 1; j++) {
276 SortArray[j]->Pnext = SortArray[j + 1];
277 }
278 SortArray[NewColorSubdiv[Index].NumEntries - 1]->Pnext = NULL;
279 NewColorSubdiv[Index].QuantizedColors = QuantizedColor =
280 SortArray[0];
281 free((char *)SortArray);
282
283 /* Now simply add the Counts until we have half of the Count: */
284 Sum = NewColorSubdiv[Index].Count / 2 - QuantizedColor->Count;
285 NumEntries = 1;
286 Count = QuantizedColor->Count;
287 while (QuantizedColor->Pnext != NULL &&
288 (Sum -= QuantizedColor->Pnext->Count) >= 0 &&
289 QuantizedColor->Pnext->Pnext != NULL) {
290 QuantizedColor = QuantizedColor->Pnext;
291 NumEntries++;
292 Count += QuantizedColor->Count;
293 }
294 /* Save the values of the last color of the first half, and
295 * first of the second half so we can update the Bounding Boxes
296 * later. Also as the colors are quantized and the BBoxes are
297 * full 0..255, they need to be rescaled.
298 */
299 MaxColor =
300 QuantizedColor->RGB[SortRGBAxis]; /* Max. of first half */
301 /* coverity[var_deref_op] */
302 MinColor =
303 // cppcheck-suppress nullPointerRedundantCheck
304 QuantizedColor->Pnext->RGB[SortRGBAxis]; /* of second */
305 MaxColor <<= (8 - BITS_PER_PRIM_COLOR);
306 MinColor <<= (8 - BITS_PER_PRIM_COLOR);
307
308 /* Partition right here: */
309 NewColorSubdiv[*NewColorMapSize].QuantizedColors =
310 QuantizedColor->Pnext;
311 QuantizedColor->Pnext = NULL;
312 NewColorSubdiv[*NewColorMapSize].Count = Count;
313 NewColorSubdiv[Index].Count -= Count;
314 NewColorSubdiv[*NewColorMapSize].NumEntries =
315 NewColorSubdiv[Index].NumEntries - NumEntries;
316 NewColorSubdiv[Index].NumEntries = NumEntries;
317 for (j = 0; j < 3; j++) {
318 NewColorSubdiv[*NewColorMapSize].RGBMin[j] =
319 NewColorSubdiv[Index].RGBMin[j];
320 NewColorSubdiv[*NewColorMapSize].RGBWidth[j] =
321 NewColorSubdiv[Index].RGBWidth[j];
322 }
323 NewColorSubdiv[*NewColorMapSize].RGBWidth[SortRGBAxis] =
324 NewColorSubdiv[*NewColorMapSize].RGBMin[SortRGBAxis] +
325 NewColorSubdiv[*NewColorMapSize].RGBWidth[SortRGBAxis] -
326 MinColor;
327 NewColorSubdiv[*NewColorMapSize].RGBMin[SortRGBAxis] = MinColor;
328
329 NewColorSubdiv[Index].RGBWidth[SortRGBAxis] =
330 MaxColor - NewColorSubdiv[Index].RGBMin[SortRGBAxis];
331
332 (*NewColorMapSize)++;
333 }
334
335 return GIF_OK;
336 }
337
338 /****************************************************************************
339 Routine called by qsort to compare two entries.
340 *****************************************************************************/
341
SortCmpRtn(const void * Entry1,const void * Entry2)342 static int SortCmpRtn(const void *Entry1, const void *Entry2) {
343 QuantizedColorType *entry1 = (*((QuantizedColorType **)Entry1));
344 QuantizedColorType *entry2 = (*((QuantizedColorType **)Entry2));
345
346 /* sort on all axes of the color space! */
347 int hash1 = entry1->RGB[SortRGBAxis] * 256 * 256 +
348 entry1->RGB[(SortRGBAxis + 1) % 3] * 256 +
349 entry1->RGB[(SortRGBAxis + 2) % 3];
350 int hash2 = entry2->RGB[SortRGBAxis] * 256 * 256 +
351 entry2->RGB[(SortRGBAxis + 1) % 3] * 256 +
352 entry2->RGB[(SortRGBAxis + 2) % 3];
353
354 return hash1 - hash2;
355 }
356
357 /* end */
358