/src/giflib-code/gifalloc.c

Source
/*****************************************************************************

 GIF construction tools

****************************************************************************/
// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: Copyright (C) Eric S. Raymond <esr@thyrsus.com>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "gif_lib.h"
#include "gif_lib_private.h"

#define MAX(x, y) (((x) > (y)) ? (x) : (y))

/******************************************************************************
 Miscellaneous utility functions
******************************************************************************/

/* return smallest bitfield size n will fit in */
int GifBitSize(int n) {
  register int i;

  for (i = 1; i <= 8; i++) {
    if ((1 << i) >= n) {
      break;
    }
  }
  return (i);
}

/******************************************************************************
 Color map object functions
******************************************************************************/

/*
 * Allocate a color map of given size; initialize with contents of
 * ColorMap if that pointer is non-NULL.
 */
ColorMapObject *GifMakeMapObject(int ColorCount, const GifColorType *ColorMap) {
  ColorMapObject *Object;

  /*** FIXME: Our ColorCount has to be a power of two.  Is it necessary to
   * make the user know that or should we automatically round up instead?
   */
  if (ColorCount != (1 << GifBitSize(ColorCount))) {
    return ((ColorMapObject *)NULL);
  }

  Object = (ColorMapObject *)malloc(sizeof(ColorMapObject));
  if (Object == (ColorMapObject *)NULL) {
    return ((ColorMapObject *)NULL);
  }

  Object->Colors =
      (GifColorType *)calloc(ColorCount, sizeof(GifColorType));
  if (Object->Colors == (GifColorType *)NULL) {
    free(Object);
    return ((ColorMapObject *)NULL);
  }

  Object->ColorCount = ColorCount;
  Object->BitsPerPixel = GifBitSize(ColorCount);
  Object->SortFlag = false;

  if (ColorMap != NULL) {
    memcpy((char *)Object->Colors, (char *)ColorMap,
           ColorCount * sizeof(GifColorType));
  }

  return (Object);
}

/*******************************************************************************
 Free a color map object
*******************************************************************************/
void GifFreeMapObject(ColorMapObject *Object) {
  if (Object != NULL) {
    (void)free(Object->Colors);
    (void)free(Object);
  }
}

#ifdef DEBUG
void DumpColorMap(ColorMapObject *Object, FILE *fp) {
  if (Object != NULL) {
    int i, j, Len = Object->ColorCount;

    for (i = 0; i < Len; i += 4) {
      for (j = 0; j < 4 && j < Len; j++) {
        (void)fprintf(fp, "%3d: %02x %02x %02x   ",
                      i + j, Object->Colors[i + j].Red,
                      Object->Colors[i + j].Green,
                      Object->Colors[i + j].Blue);
      }
      (void)fprintf(fp, "\n");
    }
  }
}
#endif /* DEBUG */

/*******************************************************************************
 Compute the union of two given color maps and return it.  If result can't
 fit into 256 colors, NULL is returned, the allocated union otherwise.
 ColorIn1 is copied as is to ColorUnion, while colors from ColorIn2 are
 copied iff they didn't exist before.  ColorTransIn2 maps the old
 ColorIn2 into the ColorUnion color map table./
*******************************************************************************/
ColorMapObject *GifUnionColorMap(const ColorMapObject *ColorIn1,
                                 const ColorMapObject *ColorIn2,
                                 GifPixelType ColorTransIn2[]) {
  int i, j, CrntSlot, RoundUpTo, NewGifBitSize;
  ColorMapObject *ColorUnion;

  /*
   * We don't worry about duplicates within either color map; if
   * the caller wants to resolve those, he can perform unions
   * with an empty color map.
   */

  /* Allocate table which will hold the result for sure. */
  ColorUnion = GifMakeMapObject(
      MAX(ColorIn1->ColorCount, ColorIn2->ColorCount) * 2, NULL);

  if (ColorUnion == NULL) {
    return (NULL);
  }

  /*
   * Copy ColorIn1 to ColorUnion.
   */
  for (i = 0; i < ColorIn1->ColorCount; i++) {
    ColorUnion->Colors[i] = ColorIn1->Colors[i];
  }
  CrntSlot = ColorIn1->ColorCount;

  /*
   * Potentially obnoxious hack:
   *
   * Back CrntSlot down past all contiguous {0, 0, 0} slots at the end
   * of table 1.  This is very useful if your display is limited to
   * 16 colors.
   */
  while (CrntSlot > 0 && (ColorIn1->Colors[CrntSlot - 1].Red == 0 &&
         ColorIn1->Colors[CrntSlot - 1].Green == 0 &&
          ColorIn1->Colors[CrntSlot - 1].Blue == 0)) {
    CrntSlot--;
  }

  /* Copy ColorIn2 to ColorUnion (use old colors if they exist): */
  for (i = 0; i < ColorIn2->ColorCount && CrntSlot <= 256; i++) {
    /* Let's see if this color already exists: */
    for (j = 0; j < ColorIn1->ColorCount; j++) {
      if (memcmp(&ColorIn1->Colors[j], &ColorIn2->Colors[i],
                 sizeof(GifColorType)) == 0) {
        break;
      }
    }

    if (j < ColorIn1->ColorCount) {
      ColorTransIn2[i] = j; /* color exists in Color1 */
    } else {
      /* Color is new - copy it to a new slot: */
      ColorUnion->Colors[CrntSlot] = ColorIn2->Colors[i];
      ColorTransIn2[i] = CrntSlot++;
    }
  }

  if (CrntSlot > 256) {
    GifFreeMapObject(ColorUnion);
    return ((ColorMapObject *)NULL);
  }

  NewGifBitSize = GifBitSize(CrntSlot);
  RoundUpTo = (1 << NewGifBitSize);

  if (RoundUpTo != ColorUnion->ColorCount) {
    register GifColorType *Map = ColorUnion->Colors;

    /*
     * Zero out slots up to next power of 2.
     * We know these slots exist because of the way ColorUnion's
     * start dimension was computed.
     */
    for (j = CrntSlot; j < RoundUpTo; j++) {
      Map[j].Red = Map[j].Green = Map[j].Blue = 0;
    }

    /* perhaps we can shrink the map? */
    if (RoundUpTo < ColorUnion->ColorCount) {
      GifColorType *new_map = (GifColorType *)reallocarray(
          Map, RoundUpTo, sizeof(GifColorType));
      if (new_map == NULL) {
        GifFreeMapObject(ColorUnion);
        return ((ColorMapObject *)NULL);
      }
      ColorUnion->Colors = new_map;
    }
  }

  ColorUnion->ColorCount = RoundUpTo;
  ColorUnion->BitsPerPixel = NewGifBitSize;

  return (ColorUnion);
}

/*******************************************************************************
 Apply a given color translation to the raster bits of an image
*******************************************************************************/
void GifApplyTranslation(SavedImage *Image, const GifPixelType Translation[]) {
  register int i;
  register int RasterSize =
      Image->ImageDesc.Height * Image->ImageDesc.Width;

  for (i = 0; i < RasterSize; i++) {
    Image->RasterBits[i] = Translation[Image->RasterBits[i]];
  }
}

/******************************************************************************
 Extension record functions
******************************************************************************/
int GifAddExtensionBlock(int *ExtensionBlockCount,
                         ExtensionBlock **ExtensionBlocks, int Function,
                         unsigned int Len, unsigned char ExtData[]) {
  ExtensionBlock *ep;

  if (*ExtensionBlocks == NULL) {
    *ExtensionBlocks =
        (ExtensionBlock *)malloc(sizeof(ExtensionBlock));
  } else {
    ExtensionBlock *ep_new = (ExtensionBlock *)reallocarray(
        *ExtensionBlocks, (*ExtensionBlockCount + 1),
        sizeof(ExtensionBlock));
    if (ep_new == NULL) {
      return (GIF_ERROR);
    }
    *ExtensionBlocks = ep_new;
  }

  if (*ExtensionBlocks == NULL) {
    return (GIF_ERROR);
  }

  ep = &(*ExtensionBlocks)[(*ExtensionBlockCount)++];

  ep->Function = Function;
  ep->ByteCount = Len;
  ep->Bytes = (GifByteType *)malloc(ep->ByteCount);
  if (ep->Bytes == NULL) {
    return (GIF_ERROR);
  }

  if (ExtData != NULL) {
    memcpy(ep->Bytes, ExtData, Len);
  }

  return (GIF_OK);
}

void GifFreeExtensions(int *ExtensionBlockCount,
                       ExtensionBlock **ExtensionBlocks) {
  ExtensionBlock *ep;

  if (*ExtensionBlocks == NULL) {
    return;
  }

  for (ep = *ExtensionBlocks;
       ep < (*ExtensionBlocks + *ExtensionBlockCount); ep++) {
    (void)free((char *)ep->Bytes);
  }
  (void)free((char *)*ExtensionBlocks);
  *ExtensionBlocks = NULL;
  *ExtensionBlockCount = 0;
}

/******************************************************************************
   Image block allocation functions
******************************************************************************/

/* Private Function:
 * Frees the last image in the GifFile->SavedImages array
 */
void FreeLastSavedImage(GifFileType *GifFile) {
  SavedImage *sp;

  if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) {
    return;
  }

  /* Remove one SavedImage from the GifFile */
  GifFile->ImageCount--;
  sp = &GifFile->SavedImages[GifFile->ImageCount];

  /* Deallocate its Colormap */
  if (sp->ImageDesc.ColorMap != NULL) {
    GifFreeMapObject(sp->ImageDesc.ColorMap);
    sp->ImageDesc.ColorMap = NULL;
  }

  /* Deallocate the image data */
  if (sp->RasterBits != NULL) {
    free((char *)sp->RasterBits);
  }

  /* Deallocate any extensions */
  GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);

  /*** FIXME: We could realloc the GifFile->SavedImages structure but is
   * there a point to it? Saves some memory but we'd have to do it every
   * time.  If this is used in GifFreeSavedImages then it would be
   * inefficient (The whole array is going to be deallocated.)  If we just
   * use it when we want to free the last Image it's convenient to do it
   * here.
   */
}

/*
 * Append an image block to the SavedImages array
 */
SavedImage *GifMakeSavedImage(GifFileType *GifFile,
                              const SavedImage *CopyFrom) {
  // cppcheck-suppress ctunullpointer
  if (GifFile->SavedImages == NULL) {
    GifFile->SavedImages = (SavedImage *)malloc(sizeof(SavedImage));
  } else {
    SavedImage *newSavedImages = (SavedImage *)reallocarray(
        GifFile->SavedImages, (GifFile->ImageCount + 1),
        sizeof(SavedImage));
    if (newSavedImages == NULL) {
      return ((SavedImage *)NULL);
    }
    GifFile->SavedImages = newSavedImages;
  }
  if (GifFile->SavedImages == NULL) {
    return ((SavedImage *)NULL);
  } else {
    SavedImage *sp = &GifFile->SavedImages[GifFile->ImageCount++];

    if (CopyFrom != NULL) {
      memcpy((char *)sp, CopyFrom, sizeof(SavedImage));

      /*
       * Make our own allocated copies of the heap fields in
       * the copied record.  This guards against potential
       * aliasing problems.
       */

      /* Null out aliased pointers before any allocations
       * so that FreeLastSavedImage won't free CopyFrom's
       * data if an allocation fails partway through. */
      sp->ImageDesc.ColorMap = NULL;
      sp->RasterBits = NULL;
      sp->ExtensionBlocks = NULL;
      sp->ExtensionBlockCount = 0;
 
      /* first, the local color map */
      if (CopyFrom->ImageDesc.ColorMap != NULL) {
        sp->ImageDesc.ColorMap = GifMakeMapObject(
            CopyFrom->ImageDesc.ColorMap->ColorCount,
            CopyFrom->ImageDesc.ColorMap->Colors);
        if (sp->ImageDesc.ColorMap == NULL) {
          FreeLastSavedImage(GifFile);
          return (SavedImage *)(NULL);
        }
      }

      /* next, the raster */
      sp->RasterBits = (unsigned char *)reallocarray(
          NULL,
          (CopyFrom->ImageDesc.Height *
           CopyFrom->ImageDesc.Width),
          sizeof(GifPixelType));
      if (sp->RasterBits == NULL) {
        FreeLastSavedImage(GifFile);
        return (SavedImage *)(NULL);
      }
      memcpy(sp->RasterBits, CopyFrom->RasterBits,
             sizeof(GifPixelType) *
                 CopyFrom->ImageDesc.Height *
                 CopyFrom->ImageDesc.Width);

      /* finally, the extension blocks */
      if (CopyFrom->ExtensionBlocks != NULL) {
        int k;
        sp->ExtensionBlocks =
            (ExtensionBlock *)calloc(
                CopyFrom->ExtensionBlockCount,
                sizeof(ExtensionBlock));
        if (sp->ExtensionBlocks == NULL) {
          FreeLastSavedImage(GifFile);
          return (SavedImage *)(NULL);
        }
        for (k = 0; k < CopyFrom->ExtensionBlockCount;
             k++) {
          ExtensionBlock *dst =
              &sp->ExtensionBlocks[k];
          ExtensionBlock *src =
              &CopyFrom->ExtensionBlocks[k];
          dst->Function = src->Function;
          dst->ByteCount = src->ByteCount;
          if (src->ByteCount > 0) {
            dst->Bytes =
                (GifByteType *)malloc(
                    src->ByteCount);
            if (dst->Bytes == NULL) {
              FreeLastSavedImage(
                  GifFile);
              return (SavedImage *)(NULL);
            }
            memcpy(dst->Bytes, src->Bytes,
                   src->ByteCount);
          }
        }
      }
    } else {
      memset((char *)sp, '\0', sizeof(SavedImage));
    }

    return (sp);
  }
}

void GifFreeSavedImages(GifFileType *GifFile) {
  SavedImage *sp;

  if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) {
    return;
  }
  for (sp = GifFile->SavedImages;
       sp < GifFile->SavedImages + GifFile->ImageCount; sp++) {
    if (sp->ImageDesc.ColorMap != NULL) {
      GifFreeMapObject(sp->ImageDesc.ColorMap);
      sp->ImageDesc.ColorMap = NULL;
    }

    if (sp->RasterBits != NULL) {
      free((char *)sp->RasterBits);
    }

    GifFreeExtensions(&sp->ExtensionBlockCount,
                      &sp->ExtensionBlocks);
  }
  free((char *)GifFile->SavedImages);
  GifFile->SavedImages = NULL;
}

/* end */

Coverage Report

Created: 2026-05-16 06:09

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