1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 /*****************************************************************************
26
27 GIF construction tools
28
29 ****************************************************************************/
30
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34
35 #include "gif_lib.h"
36
37 #define MAX(x, y) (((x) > (y)) ? (x) : (y))
38
39 /******************************************************************************
40 Miscellaneous utility functions
41 ******************************************************************************/
42
43 /* return smallest bitfield size n will fit in */
44 int
45 GifBitSize(int n)
46 {
47 register int i;
48
49 for (i = 1; i <= 8; i++)
50 if ((1 << i) >= n)
51 break;
52 return (i);
53 }
54
55 /******************************************************************************
56 Color map object functions
57 ******************************************************************************/
58
59 /*
60 * Allocate a color map of given size; initialize with contents of
61 * ColorMap if that pointer is non-NULL.
62 */
63 ColorMapObject *
64 GifMakeMapObject(int ColorCount, const GifColorType *ColorMap)
65 {
66 ColorMapObject *Object;
67
68 /*** FIXME: Our ColorCount has to be a power of two. Is it necessary to
69 * make the user know that or should we automatically round up instead? */
70 if (ColorCount != (1 << GifBitSize(ColorCount))) {
71 return ((ColorMapObject *) NULL);
72 }
73
74 Object = (ColorMapObject *)malloc(sizeof(ColorMapObject));
75 if (Object == (ColorMapObject *) NULL) {
76 return ((ColorMapObject *) NULL);
77 }
78
79 Object->Colors = (GifColorType *)calloc(ColorCount, sizeof(GifColorType));
80 if (Object->Colors == (GifColorType *) NULL) {
81 free(Object);
82 return ((ColorMapObject *) NULL);
83 }
84
85 Object->ColorCount = ColorCount;
86 Object->BitsPerPixel = GifBitSize(ColorCount);
87 Object->SortFlag = false;
88
89 if (ColorMap != NULL) {
90 memcpy((char *)Object->Colors,
91 (char *)ColorMap, ColorCount * sizeof(GifColorType));
92 }
93
94 return (Object);
95 }
96
97 /*******************************************************************************
98 Free a color map object
99 *******************************************************************************/
100 void
101 GifFreeMapObject(ColorMapObject *Object)
102 {
103 if (Object != NULL) {
104 (void)free(Object->Colors);
105 (void)free(Object);
106 }
107 }
108
109 #ifdef DEBUG
110 void
111 DumpColorMap(ColorMapObject *Object,
112 FILE * fp)
113 {
114 if (Object != NULL) {
115 int i, j, Len = Object->ColorCount;
116
117 for (i = 0; i < Len; i += 4) {
118 for (j = 0; j < 4 && j < Len; j++) {
119 (void)fprintf(fp, "%3d: %02x %02x %02x ", i + j,
120 Object->Colors[i + j].Red,
121 Object->Colors[i + j].Green,
122 Object->Colors[i + j].Blue);
123 }
124 (void)fprintf(fp, "\n");
125 }
126 }
127 }
128 #endif /* DEBUG */
129
130 /*******************************************************************************
131 Compute the union of two given color maps and return it. If result can't
132 fit into 256 colors, NULL is returned, the allocated union otherwise.
133 ColorIn1 is copied as is to ColorUnion, while colors from ColorIn2 are
134 copied iff they didn't exist before. ColorTransIn2 maps the old
135 ColorIn2 into the ColorUnion color map table./
136 *******************************************************************************/
137 ColorMapObject *
138 GifUnionColorMap(const ColorMapObject *ColorIn1,
139 const ColorMapObject *ColorIn2,
140 GifPixelType ColorTransIn2[])
141 {
142 int i, j, CrntSlot, RoundUpTo, NewGifBitSize;
143 ColorMapObject *ColorUnion;
144
145 /*
146 * We don't worry about duplicates within either color map; if
147 * the caller wants to resolve those, he can perform unions
148 * with an empty color map.
149 */
150
151 /* Allocate table which will hold the result for sure. */
152 ColorUnion = GifMakeMapObject(MAX(ColorIn1->ColorCount,
153 ColorIn2->ColorCount) * 2, NULL);
154
155 if (ColorUnion == NULL)
156 return (NULL);
157
158 /*
159 * Copy ColorIn1 to ColorUnion.
160 */
161 for (i = 0; i < ColorIn1->ColorCount; i++)
162 ColorUnion->Colors[i] = ColorIn1->Colors[i];
163 CrntSlot = ColorIn1->ColorCount;
164
165 /*
166 * Potentially obnoxious hack:
167 *
168 * Back CrntSlot down past all contiguous {0, 0, 0} slots at the end
169 * of table 1. This is very useful if your display is limited to
170 * 16 colors.
171 */
172 while (ColorIn1->Colors[CrntSlot - 1].Red == 0
173 && ColorIn1->Colors[CrntSlot - 1].Green == 0
174 && ColorIn1->Colors[CrntSlot - 1].Blue == 0)
175 CrntSlot--;
176
177 /* Copy ColorIn2 to ColorUnion (use old colors if they exist): */
178 for (i = 0; i < ColorIn2->ColorCount && CrntSlot <= 256; i++) {
179 /* Let's see if this color already exists: */
180 for (j = 0; j < ColorIn1->ColorCount; j++)
181 if (memcmp (&ColorIn1->Colors[j], &ColorIn2->Colors[i],
182 sizeof(GifColorType)) == 0)
183 break;
184
185 if (j < ColorIn1->ColorCount)
186 ColorTransIn2[i] = j; /* color exists in Color1 */
187 else {
188 /* Color is new - copy it to a new slot: */
189 ColorUnion->Colors[CrntSlot] = ColorIn2->Colors[i];
190 ColorTransIn2[i] = CrntSlot++;
191 }
192 }
193
194 if (CrntSlot > 256) {
195 GifFreeMapObject(ColorUnion);
196 return ((ColorMapObject *) NULL);
197 }
198
199 NewGifBitSize = GifBitSize(CrntSlot);
200 RoundUpTo = (1 << NewGifBitSize);
201
202 if (RoundUpTo != ColorUnion->ColorCount) {
203 register GifColorType *Map = ColorUnion->Colors;
204
205 /*
206 * Zero out slots up to next power of 2.
207 * We know these slots exist because of the way ColorUnion's
208 * start dimension was computed.
209 */
210 for (j = CrntSlot; j < RoundUpTo; j++)
211 Map[j].Red = Map[j].Green = Map[j].Blue = 0;
212
213 /* perhaps we can shrink the map? */
214 if (RoundUpTo < ColorUnion->ColorCount) {
215 GifColorType *new_map = (GifColorType *)realloc(Map,
216 sizeof(GifColorType) * RoundUpTo);
217 if( new_map == NULL ) {
218 GifFreeMapObject(ColorUnion);
219 return ((ColorMapObject *) NULL);
220 }
221 ColorUnion->Colors = new_map;
222 }
223 }
224
225 ColorUnion->ColorCount = RoundUpTo;
226 ColorUnion->BitsPerPixel = NewGifBitSize;
227
228 return (ColorUnion);
229 }
230
231 /*******************************************************************************
232 Apply a given color translation to the raster bits of an image
233 *******************************************************************************/
234 void
235 GifApplyTranslation(SavedImage *Image, GifPixelType Translation[])
236 {
237 register int i;
238 register int RasterSize = Image->ImageDesc.Height * Image->ImageDesc.Width;
239
240 for (i = 0; i < RasterSize; i++)
241 Image->RasterBits[i] = Translation[Image->RasterBits[i]];
242 }
243
244 /******************************************************************************
245 Extension record functions
246 ******************************************************************************/
247 int
248 GifAddExtensionBlock(int *ExtensionBlockCount,
249 ExtensionBlock **ExtensionBlocks,
250 int Function,
251 unsigned int Len,
252 unsigned char ExtData[])
253 {
254 ExtensionBlock *ep;
255
256 if (*ExtensionBlocks == NULL)
257 *ExtensionBlocks=(ExtensionBlock *)malloc(sizeof(ExtensionBlock));
258 else {
259 ExtensionBlock* ep_new = (ExtensionBlock *)realloc(*ExtensionBlocks,
260 sizeof(ExtensionBlock) *
261 (*ExtensionBlockCount + 1));
262 if( ep_new == NULL )
263 return (GIF_ERROR);
264 *ExtensionBlocks = ep_new;
265 }
266
267 if (*ExtensionBlocks == NULL)
268 return (GIF_ERROR);
269
270 ep = &(*ExtensionBlocks)[(*ExtensionBlockCount)++];
271
272 ep->Function = Function;
273 ep->ByteCount=Len;
274 ep->Bytes = (GifByteType *)malloc(ep->ByteCount);
275 if (ep->Bytes == NULL)
276 return (GIF_ERROR);
277
278 if (ExtData != NULL) {
279 memcpy(ep->Bytes, ExtData, Len);
280 }
281
282 return (GIF_OK);
283 }
284
285 void
286 GifFreeExtensions(int *ExtensionBlockCount,
287 ExtensionBlock **ExtensionBlocks)
288 {
289 ExtensionBlock *ep;
290
291 if (*ExtensionBlocks == NULL)
292 return;
293
294 for (ep = *ExtensionBlocks;
295 ep < (*ExtensionBlocks + *ExtensionBlockCount);
296 ep++)
297 (void)free((char *)ep->Bytes);
298 (void)free((char *)*ExtensionBlocks);
299 *ExtensionBlocks = NULL;
300 *ExtensionBlockCount = 0;
301 }
302
303 /******************************************************************************
304 Image block allocation functions
305 ******************************************************************************/
306
307 /* Private Function:
308 * Frees the last image in the GifFile->SavedImages array
309 */
310 void
311 FreeLastSavedImage(GifFileType *GifFile)
312 {
313 SavedImage *sp;
314
315 if ((GifFile == NULL) || (GifFile->SavedImages == NULL))
316 return;
317
318 /* Remove one SavedImage from the GifFile */
319 GifFile->ImageCount--;
320 sp = &GifFile->SavedImages[GifFile->ImageCount];
321
322 /* Deallocate its Colormap */
323 if (sp->ImageDesc.ColorMap != NULL) {
324 GifFreeMapObject(sp->ImageDesc.ColorMap);
325 sp->ImageDesc.ColorMap = NULL;
326 }
327
328 /* Deallocate the image data */
329 if (sp->RasterBits != NULL)
330 free((char *)sp->RasterBits);
331
332 /* Deallocate any extensions */
333 GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
334
335 /*** FIXME: We could realloc the GifFile->SavedImages structure but is
336 * there a point to it? Saves some memory but we'd have to do it every
337 * time. If this is used in GifFreeSavedImages then it would be inefficient
338 * (The whole array is going to be deallocated.) If we just use it when
339 * we want to free the last Image it's convenient to do it here.
340 */
341 }
342
343 /*
344 * Append an image block to the SavedImages array
345 */
346 SavedImage *
347 GifMakeSavedImage(GifFileType *GifFile, const SavedImage *CopyFrom)
348 {
349 if (GifFile->SavedImages == NULL)
350 GifFile->SavedImages = (SavedImage *)malloc(sizeof(SavedImage));
351 else
352 GifFile->SavedImages = (SavedImage *)realloc(GifFile->SavedImages,
353 sizeof(SavedImage) * (GifFile->ImageCount + 1));
354
355 if (GifFile->SavedImages == NULL)
356 return ((SavedImage *)NULL);
357 else {
358 SavedImage *sp = &GifFile->SavedImages[GifFile->ImageCount++];
359 memset((char *)sp, '\0', sizeof(SavedImage));
360
361 if (CopyFrom != NULL) {
362 memcpy((char *)sp, CopyFrom, sizeof(SavedImage));
363
364 /*
365 * Make our own allocated copies of the heap fields in the
366 * copied record. This guards against potential aliasing
367 * problems.
368 */
369
370 /* first, the local color map */
371 if (sp->ImageDesc.ColorMap != NULL) {
372 sp->ImageDesc.ColorMap = GifMakeMapObject(
373 CopyFrom->ImageDesc.ColorMap->ColorCount,
374 CopyFrom->ImageDesc.ColorMap->Colors);
375 if (sp->ImageDesc.ColorMap == NULL) {
376 FreeLastSavedImage(GifFile);
377 return (SavedImage *)(NULL);
378 }
379 }
380
381 /* next, the raster */
382 sp->RasterBits = (unsigned char *)malloc(sizeof(GifPixelType) *
383 CopyFrom->ImageDesc.Height *
384 CopyFrom->ImageDesc.Width);
385 if (sp->RasterBits == NULL) {
386 FreeLastSavedImage(GifFile);
387 return (SavedImage *)(NULL);
388 }
389 memcpy(sp->RasterBits, CopyFrom->RasterBits,
390 sizeof(GifPixelType) * CopyFrom->ImageDesc.Height *
391 CopyFrom->ImageDesc.Width);
392
393 /* finally, the extension blocks */
394 if (sp->ExtensionBlocks != NULL) {
395 sp->ExtensionBlocks = (ExtensionBlock *)malloc(
396 sizeof(ExtensionBlock) *
397 CopyFrom->ExtensionBlockCount);
398 if (sp->ExtensionBlocks == NULL) {
399 FreeLastSavedImage(GifFile);
400 return (SavedImage *)(NULL);
401 }
402 memcpy(sp->ExtensionBlocks, CopyFrom->ExtensionBlocks,
403 sizeof(ExtensionBlock) * CopyFrom->ExtensionBlockCount);
404 }
405 }
406
407 return (sp);
408 }
409 }
410
411 void
412 GifFreeSavedImages(GifFileType *GifFile)
413 {
414 SavedImage *sp;
415
416 if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) {
417 return;
418 }
419 for (sp = GifFile->SavedImages;
420 sp < GifFile->SavedImages + GifFile->ImageCount; sp++) {
421 if (sp->ImageDesc.ColorMap != NULL) {
422 GifFreeMapObject(sp->ImageDesc.ColorMap);
423 sp->ImageDesc.ColorMap = NULL;
424 }
425
426 if (sp->RasterBits != NULL)
427 free((char *)sp->RasterBits);
428
429 GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
430 }
431 free((char *)GifFile->SavedImages);
432 GifFile->SavedImages = NULL;
433 }
434
435 /* end */