[occt.git] / src / Xw / Xw_load_gif_image.cxx

// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

/*
 * Created:  zov : 22-Apr-1998  : Loads GIF image from file
 *

   XW_EXT_IMAGEDATA* Xw_load_gif_image (awindow,aimageinfo,fimage,ppcolors,pncolors)
   XW_EXT_WINDOW *awindow
   XW_USERDATA   *aimageinfo
   XColor **ppcolors - address of pointer to array of used colors to return
   int *pncolors - address of a variable to return length of the array in

   Gets an image from a file.
   Note, that the file must be GIF formatted.

   Returns the image descriptor address if successful; or NULL if failed.
*/

#define PURIFY 	/*GG+STT 11/01/99
//		Avoid Free memory leak.
*/

#include <Xw_Extension.h>
#include <fcntl.h>


#define         _ADD_PIXEL(idx)                                      \
{                                                                    \
  if (y < height)  *(pidata + y*width + x) = ((unsigned char)(idx)); \
  if (++x == width) {                                                \
    x = 0;                                                           \
    if (!isInterlace)  ++y;                                          \
    else  switch (pass) {                                            \
    case 0:  y += 8; if (y >= height) ++pass, y = 4; break;          \
    case 1:  y += 8; if (y >= height) ++pass, y = 2; break;          \
    case 2:  y += 4; if (y >= height) ++pass, y = 1; break;          \
    default: y += 2;                                                 \
    }                                                                \
  }                                                                  \
}

/* Note,
** Portions Copyright (c) of CISIGRAPH SOFTWARE.
**
** Permission to use, copy, modify, and distribute this software and its
** documentation for any purpose and without fee is hereby granted, provided
** that the above copyright notice appear in all copies and that both that
** copyright notice and this permission notice appear in supporting
** documentation.  This software is provided "as is" without express or
** implied warranty.
*/

XW_EXT_IMAGEDATA *Xw_load_gif_image (void *awindow,void *aimageinfo,char *filename,int fimage,
                         XColor **ppcolors, int *pncolors)
{
//  XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW *)awindow;
  XW_EXT_IMAGEDATA *pimage = NULL;
//  XW_STATUS status;
  XImage *pximage = NULL;
  XColor *pcolors = NULL;
  char *wname = NULL, *pidata = NULL;
  unsigned char byte, byte1;
  unsigned *OutCode=NULL, *Prefix=NULL, *Suffix=NULL,
    BitMask, CodeSize, ClearCode, EOFCode, FreeCode, x, y, pass, width, height,
    InitCodeSize, MaxCode, ReadMask, FirstFree, OutCount, BitOffset,
    ByteOffset, Code, CurCode, OldCode=0, FinChar=0, InCode;
  long lFileSize;
//  int i, isize, dataSize, ncolors;
  int i, ncolors;
static  unsigned char *pchFileStream_start = NULL,
                *pchFileStream, *ptr1, *rasterPtr = NULL;
  int isInterlace, hasColormap;


  if (-1 == (lFileSize = lseek (fimage, 0, SEEK_END))
      || NULL == (pchFileStream_start = (unsigned char *) Xw_malloc (lFileSize))
      || 0 != lseek (fimage, 0, SEEK_SET)
      || lFileSize != read (fimage, (char *)pchFileStream_start, lFileSize)
      ) 
    goto _ExitReadError;

  pchFileStream = pchFileStream_start + 10;


  byte = *pchFileStream++; /* Color descriptor byte (M#CR0#BP) */
  hasColormap = byte & 0x80;
  ncolors = hasColormap ? 1<<((byte & 0x07) + 1): 1<<8;
  BitMask = ncolors - 1;

#ifdef DEBUG
  fprintf (stderr, "\r\nXw_load_gif_image: GIF contains %d colors.",
	   hasColormap? ncolors: 0);
#endif /*DEBUG*/

  pchFileStream += 2; /* Skip background byte and following zero byte */

  if (ncolors > 0) { /* Allocate Color Table entries */

    if (! (pcolors = (XColor*) Xw_calloc(ncolors, sizeof(XColor))))
      goto _ExitAllocError;

    for (i=0; i<ncolors; i++) { /* Fill in array of XColor's used */

      /* Note, that if there's no colormap specified then I use green scale */
      pcolors[i].red = ((int)(hasColormap ? *pchFileStream++: i)) << 8; /*map to 0:ffff*/
      pcolors[i].green = ((int)(hasColormap ? *pchFileStream++: i)) << 8;
      pcolors[i].blue = ((int)(hasColormap ? *pchFileStream++: i)) << 8;

      pcolors[i].flags = DoRed|DoGreen|DoBlue;

      pcolors[i].pixel = i;
      pcolors[i].pad = 0;
    }
  }


#ifdef DEBUG
  if (*pchFileStream == '!')
    fprintf (stderr, "\r\nXw_load_gif_image: GIF contains extension blocks"
	     " (code: %x).", (int)*(pchFileStream + 1));
  else 
    fprintf (stderr, "\r\nXw_load_gif_image: GIF has no extension blocks.");
#endif /*DEBUG*/


  /* Skip extension blocks if any.
   * Format:  <'!'><size><...><size><...><0>
   */
  while (*pchFileStream == '!') {

    pchFileStream += 2;  /* skip code byte followed '!' sign */

    while (*pchFileStream)
      pchFileStream += (unsigned)(1 + *(unsigned char *)pchFileStream);

    pchFileStream ++;
  }
 

  if (*pchFileStream++ != ',') { /* must be an image descriptor */

#ifdef DEB
    fprintf (stderr, "\r\nXw_load_gif_image: Error: There's no separator"
	     " following the colormap");
#endif /*DEB*/

    goto _ExitReadError;
  }


  pchFileStream += 2*2; /* Skip image left & top offsets*/
  width = (unsigned) *pchFileStream++;
  width += ((unsigned)*pchFileStream++) << 8;
  height = (unsigned) *pchFileStream++;
  height += ((unsigned)*pchFileStream++) << 8;

    
  byte = *pchFileStream++;

  isInterlace = byte & 0x40;

  if (byte & 0x80) {

    fprintf (stderr, "\r\nXw_load_gif_image:"
	     " Can't read GIF image with locally defined colormap!\r\n");
    goto _ExitReadError;
  }

  
#ifdef DEBUG
    fprintf (stderr, "\r\nXw_load_gif_image: Dimensions: %dx%d"
	     "  Interlace mode: %s",
	     width, height, isInterlace? "ON": "OFF");
#endif /*DEBUG*/


  /* Allocate the pixel buffer */
  if (! (rasterPtr = (unsigned char *) Xw_malloc(lFileSize)))
    goto _ExitAllocError;


  OutCode = (unsigned *)Xw_malloc(1025 * sizeof (unsigned));
  Prefix  = (unsigned *)Xw_malloc(4096 * sizeof (unsigned));
  Suffix  = (unsigned *)Xw_malloc(4096 * sizeof (unsigned));

  if (!OutCode || !Prefix || !Suffix)
    goto _ExitAllocError;


  /* Decode compressed raster data. */
  CodeSize  = *pchFileStream++;
  ClearCode = 1 << CodeSize;
  EOFCode   = ClearCode + 1;
  FreeCode  = FirstFree = EOFCode + 1;

  ++CodeSize;

  InitCodeSize = CodeSize;
  MaxCode      = 1 << CodeSize;
  ReadMask     = MaxCode - 1;

  ptr1 = rasterPtr;

  /* Read encoded data to a continuous array pointed to by rsterPtr */
  do {
    byte = byte1 = *pchFileStream++;

    while (byte--)
      *ptr1++ = *pchFileStream++;

    if ((long) (ptr1 - rasterPtr) > lFileSize)  /* Currupt file */
      goto _ExitReadError;
  }
  while (byte1);

  Xw_free (pchFileStream_start); /* The file data has been already read */
  pchFileStream_start = NULL;


  if (! (pidata = (char *) Xw_malloc (width*height)))
    goto _ExitAllocError;


  x = y = pass = OutCount = BitOffset = ByteOffset = 0;

  /* Fetch the next code (3 to 12 bits) from the raster data stream */
  Code = rasterPtr[0] + (((unsigned) rasterPtr[1]) << 8);
  if (CodeSize >= 8)
    Code += ((unsigned) rasterPtr[2]) << 16;

  Code >>= BitOffset & 0x7;
  BitOffset += CodeSize;
  Code      &= ReadMask;


  while (Code != EOFCode) {

  
    if (Code == ClearCode) {
   
      /* Read the next code */
      CodeSize   = InitCodeSize;
      MaxCode    = 1 << CodeSize;
      ReadMask   = MaxCode - 1;
      FreeCode   = FirstFree;
      ByteOffset = BitOffset >> 3;
      Code       = rasterPtr[ByteOffset];

      Code       = rasterPtr[ByteOffset]
	           + (((unsigned) rasterPtr[ByteOffset + 1]) << 8);
      if (CodeSize >= 8)
	Code += ((unsigned) rasterPtr[ByteOffset + 2]) << 16;

      Code      >>= BitOffset & 0x7;
      BitOffset +=  CodeSize;
      Code      &=  ReadMask;

      CurCode = OldCode = Code;
      FinChar = CurCode & BitMask;

      _ADD_PIXEL (FinChar);
    }
    else {
   
      CurCode = InCode = Code;

      if (CurCode >= FreeCode) {
	
	CurCode = OldCode;
	OutCode[OutCount++] = FinChar;
      }

      while (CurCode > BitMask) {
	
	if (OutCount > 1024)
	  goto _ExitReadError;

	OutCode [OutCount++] = Suffix [CurCode];
	CurCode = Prefix [CurCode];
      }

      FinChar = CurCode & BitMask;
      OutCode [OutCount++] = FinChar;

      for (i = OutCount - 1; i >= 0; --i)
	_ADD_PIXEL (OutCode [i]);

      OutCount = 0;
      Prefix [FreeCode] = OldCode;
      Suffix [FreeCode] = FinChar;
      OldCode = InCode;
      ++FreeCode;

      if (FreeCode >= MaxCode) {
	
	if (CodeSize < 12) {
     
	  ++CodeSize;
	  MaxCode <<= 1;
	  ReadMask = (1 << CodeSize) - 1;
    	}
      }
    }

    ByteOffset = BitOffset >> 3;
    Code = (unsigned) rasterPtr[ByteOffset];
    Code = (unsigned) rasterPtr[ByteOffset]
           + (((unsigned) rasterPtr[ByteOffset + 1]) << 8);
    if (CodeSize >= 8)
      Code += ((unsigned) rasterPtr[ByteOffset + 2]) << 16;

    Code >>= (BitOffset & 0x7);
    BitOffset += CodeSize;
    Code &=  ReadMask;
  }
  

  /* Allocate the Image structure */
  if (! (pximage = (XImage*) Xw_malloc(sizeof(XImage))))
    goto _ExitAllocError;

  /* Allocate the Extended Image structure */
  if(! (pimage = Xw_add_imagedata_structure (sizeof(XW_EXT_IMAGEDATA))))
    goto _ExitError;


  /* Initialize the input image */
  pimage->pimageinfo = aimageinfo;
  _IIMAGE = pximage;
  _IIMAGE->data = pidata;
  _IIMAGE->width = (int) width;
  _IIMAGE->height = (int) height;
  _IIMAGE->xoffset = (int) 0;
  _IIMAGE->format = (int) ZPixmap;
  _IIMAGE->byte_order = (int) LSBFirst;
  _IIMAGE->bitmap_unit = (int) 8;
  _IIMAGE->bitmap_bit_order = (int) LSBFirst;
  _IIMAGE->bitmap_pad = (int) 8;
  _IIMAGE->depth = (int) 24;
  _IIMAGE->bits_per_pixel = (int) 8;
  _IIMAGE->bytes_per_line = (int) width;
  _IIMAGE->red_mask = 0;
  _IIMAGE->green_mask = 0;
  _IIMAGE->blue_mask = 0;
  _IIMAGE->obdata = NULL ;
  _XInitImageFuncPtrs (_IIMAGE);


  /* Return array of colors */
  *ppcolors = pcolors;
  *pncolors = ncolors;

  if (wname) Xw_free(wname);


#ifdef DEBUG
  fprintf (stderr, "\r\nXw_load_gif_image: Operation completed successfully.\r\n");
#endif /*DEBUG*/


  /* Successfully loaded */

#ifdef PURIFY
  if (rasterPtr) Xw_free (rasterPtr);
  if (OutCode) Xw_free (OutCode);
  if (Prefix) Xw_free (Prefix);
  if (Suffix) Xw_free (Suffix);
#endif
  return (pimage);


_ExitReadError:

  /*ERROR*Unable to read Image data
  Xw_set_error(61,"Xw_load_gif_image",filename);
  */
  fprintf (stderr, "\r\nXw_load_gif_image: Error reading %s!", filename);
  goto _ExitError;


_ExitAllocError:
  /*ERROR*Bad Image allocation
  Xw_set_error(60,"Xw_load_gif_image",0);
  */
  fprintf (stderr, "\r\nXw_load_gif_image: Error: Out of memory!");


_ExitError:

#ifdef DEB
  fprintf (stderr, "\r\nXw_load_gif_image: An error occured! Returning NULL.");
#endif /*DEB*/

  if (pchFileStream_start) Xw_free (pchFileStream_start);
  if (pximage) Xw_free (pximage);
  if (rasterPtr) Xw_free (rasterPtr);
  if (pidata) Xw_free (pidata);
  if (pimage) Xw_free (pidata);
  if (pcolors) Xw_free (pcolors);
  if (OutCode) Xw_free (OutCode);
  if (Prefix) Xw_free (Prefix);
  if (Suffix) Xw_free (Suffix);
  
  return (NULL);
}

#undef _ADD_PIXEL
Commit	Line	Data
b311480e	1	// Copyright (c) 1999-2012 OPEN CASCADE SAS
	2	//
	3	// The content of this file is subject to the Open CASCADE Technology Public
	4	// License Version 6.5 (the "License"). You may not use the content of this file
	5	// except in compliance with the License. Please obtain a copy of the License
	6	// at http://www.opencascade.org and read it completely before using this file.
	7	//
	8	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	9	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	10	//
	11	// The Original Code and all software distributed under the License is
	12	// distributed on an "AS IS" basis, without warranty of any kind, and the
	13	// Initial Developer hereby disclaims all such warranties, including without
	14	// limitation, any warranties of merchantability, fitness for a particular
	15	// purpose or non-infringement. Please see the License for the specific terms
	16	// and conditions governing the rights and limitations under the License.
	17
7fd59977	18	/*
	19	* Created: zov : 22-Apr-1998 : Loads GIF image from file
	20	*
	21
	22	XW_EXT_IMAGEDATA* Xw_load_gif_image (awindow,aimageinfo,fimage,ppcolors,pncolors)
	23	XW_EXT_WINDOW *awindow
	24	XW_USERDATA *aimageinfo
	25	XColor **ppcolors - address of pointer to array of used colors to return
	26	int *pncolors - address of a variable to return length of the array in
	27
	28	Gets an image from a file.
	29	Note, that the file must be GIF formatted.
	30
	31	Returns the image descriptor address if successful; or NULL if failed.
	32	*/
	33
	34	#define PURIFY /*GG+STT 11/01/99
	35	// Avoid Free memory leak.
	36	*/
	37
	38	#include <Xw_Extension.h>
	39	#include <fcntl.h>
	40
	41
	42	#define _ADD_PIXEL(idx) \
	43	{ \
	44	if (y < height) (pidata + ywidth + x) = ((unsigned char)(idx)); \
	45	if (++x == width) { \
	46	x = 0; \
	47	if (!isInterlace) ++y; \
	48	else switch (pass) { \
	49	case 0: y += 8; if (y >= height) ++pass, y = 4; break; \
	50	case 1: y += 8; if (y >= height) ++pass, y = 2; break; \
	51	case 2: y += 4; if (y >= height) ++pass, y = 1; break; \
	52	default: y += 2; \
	53	} \
	54	} \
	55	}
	56
	57	/* Note,
	58	** Portions Copyright (c) of CISIGRAPH SOFTWARE.
	59	**
	60	** Permission to use, copy, modify, and distribute this software and its
	61	** documentation for any purpose and without fee is hereby granted, provided
	62	** that the above copyright notice appear in all copies and that both that
	63	** copyright notice and this permission notice appear in supporting
	64	** documentation. This software is provided "as is" without express or
	65	** implied warranty.
	66	*/
	67
	68	XW_EXT_IMAGEDATA Xw_load_gif_image (void awindow,void aimageinfo,char filename,int fimage,
	69	XColor *ppcolors, int pncolors)
	70	{
	71	// XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW )awindow;
	72	XW_EXT_IMAGEDATA *pimage = NULL;
	73	// XW_STATUS status;
	74	XImage *pximage = NULL;
	75	XColor *pcolors = NULL;
	76	char wname = NULL, pidata = NULL;
	77	unsigned char byte, byte1;
	78	unsigned OutCode=NULL, Prefix=NULL, *Suffix=NULL,
	79	BitMask, CodeSize, ClearCode, EOFCode, FreeCode, x, y, pass, width, height,
	80	InitCodeSize, MaxCode, ReadMask, FirstFree, OutCount, BitOffset,
	81	ByteOffset, Code, CurCode, OldCode=0, FinChar=0, InCode;
82	long lFileSize;
83	// int i, isize, dataSize, ncolors;
84	int i, ncolors;
85	static unsigned char *pchFileStream_start = NULL,
86	pchFileStream, ptr1, *rasterPtr = NULL;
87	int isInterlace, hasColormap;
88
89
90	if (-1 == (lFileSize = lseek (fimage, 0, SEEK_END))
91	\|\| NULL == (pchFileStream_start = (unsigned char *) Xw_malloc (lFileSize))
92	\|\| 0 != lseek (fimage, 0, SEEK_SET)
93	\|\| lFileSize != read (fimage, (char *)pchFileStream_start, lFileSize)
94	)
95	goto _ExitReadError;
96
97	pchFileStream = pchFileStream_start + 10;
98
99
100	byte = pchFileStream++; / Color descriptor byte (M#CR0#BP) */
101	hasColormap = byte & 0x80;
102	ncolors = hasColormap ? 1<<((byte & 0x07) + 1): 1<<8;
103	BitMask = ncolors - 1;
104
105	#ifdef DEBUG
106	fprintf (stderr, "\r\nXw_load_gif_image: GIF contains %d colors.",
107	hasColormap? ncolors: 0);
108	#endif /DEBUG/
109
110	pchFileStream += 2; /* Skip background byte and following zero byte */
111
112	if (ncolors > 0) { /* Allocate Color Table entries */
113
114	if (! (pcolors = (XColor*) Xw_calloc(ncolors, sizeof(XColor))))
115	goto _ExitAllocError;
116
117	for (i=0; i<ncolors; i++) { /* Fill in array of XColor's used */
118
119	/* Note, that if there's no colormap specified then I use green scale */
120	pcolors[i].red = ((int)(hasColormap ? pchFileStream++: i)) << 8; /map to 0:ffff*/
121	pcolors[i].green = ((int)(hasColormap ? *pchFileStream++: i)) << 8;
122	pcolors[i].blue = ((int)(hasColormap ? *pchFileStream++: i)) << 8;
123
124	pcolors[i].flags = DoRed\|DoGreen\|DoBlue;
125
126	pcolors[i].pixel = i;
127	pcolors[i].pad = 0;
128	}
129	}
130
131
132	#ifdef DEBUG
133	if (*pchFileStream == '!')
134	fprintf (stderr, "\r\nXw_load_gif_image: GIF contains extension blocks"
135	" (code: %x).", (int)*(pchFileStream + 1));
136	else
137	fprintf (stderr, "\r\nXw_load_gif_image: GIF has no extension blocks.");
138	#endif /DEBUG/
139
140
141	/* Skip extension blocks if any.
142	* Format: <'!'><size><...><size><...><0>
143	*/
144	while (*pchFileStream == '!') {
145
146	pchFileStream += 2; /* skip code byte followed '!' sign */
147
148	while (*pchFileStream)
149	pchFileStream += (unsigned)(1 + (unsigned char )pchFileStream);
150
151	pchFileStream ++;
152	}
153
154
155
156	if (pchFileStream++ != ',') { / must be an image descriptor */
157
158	#ifdef DEB
159	fprintf (stderr, "\r\nXw_load_gif_image: Error: There's no separator"
160	" following the colormap");
161	#endif /DEB/
162
163	goto _ExitReadError;
164	}
165
166
167	pchFileStream += 22; / Skip image left & top offsets*/
168	width = (unsigned) *pchFileStream++;
169	width += ((unsigned)*pchFileStream++) << 8;
170	height = (unsigned) *pchFileStream++;
171	height += ((unsigned)*pchFileStream++) << 8;
172
173
174	byte = *pchFileStream++;
175
176	isInterlace = byte & 0x40;
177
178	if (byte & 0x80) {
179
180	fprintf (stderr, "\r\nXw_load_gif_image:"
181	" Can't read GIF image with locally defined colormap!\r\n");
182	goto _ExitReadError;
183	}
184
185
186	#ifdef DEBUG
187	fprintf (stderr, "\r\nXw_load_gif_image: Dimensions: %dx%d"
188	" Interlace mode: %s",
189	width, height, isInterlace? "ON": "OFF");
190	#endif /DEBUG/
191
192
193
194	/* Allocate the pixel buffer */
195	if (! (rasterPtr = (unsigned char *) Xw_malloc(lFileSize)))
196	goto _ExitAllocError;
197
198
199	OutCode = (unsigned )Xw_malloc(1025 sizeof (unsigned));
200	Prefix = (unsigned )Xw_malloc(4096 sizeof (unsigned));
201	Suffix = (unsigned )Xw_malloc(4096 sizeof (unsigned));
202
203	if (!OutCode \|\| !Prefix \|\| !Suffix)
204	goto _ExitAllocError;
205
206
207
208	/* Decode compressed raster data. */
209	CodeSize = *pchFileStream++;
210	ClearCode = 1 << CodeSize;
211	EOFCode = ClearCode + 1;
212	FreeCode = FirstFree = EOFCode + 1;
213
214	++CodeSize;
215
216	InitCodeSize = CodeSize;
217	MaxCode = 1 << CodeSize;
218	ReadMask = MaxCode - 1;
219
220	ptr1 = rasterPtr;
221
222	/* Read encoded data to a continuous array pointed to by rsterPtr */
223	do {
224	byte = byte1 = *pchFileStream++;
225
226	while (byte--)
227	ptr1++ = pchFileStream++;
228
229	if ((long) (ptr1 - rasterPtr) > lFileSize) /* Currupt file */
230	goto _ExitReadError;
231	}
232	while (byte1);
233
234	Xw_free (pchFileStream_start); /* The file data has been already read */
235	pchFileStream_start = NULL;
236
237
238
239	if (! (pidata = (char ) Xw_malloc (widthheight)))
240	goto _ExitAllocError;
241
242
243	x = y = pass = OutCount = BitOffset = ByteOffset = 0;
244
245	/* Fetch the next code (3 to 12 bits) from the raster data stream */
246	Code = rasterPtr[0] + (((unsigned) rasterPtr[1]) << 8);
247	if (CodeSize >= 8)
248	Code += ((unsigned) rasterPtr[2]) << 16;
249
250	Code >>= BitOffset & 0x7;
251	BitOffset += CodeSize;
252	Code &= ReadMask;
253
254
255	while (Code != EOFCode) {
256
257
258	if (Code == ClearCode) {
259
260	/* Read the next code */
261	CodeSize = InitCodeSize;
262	MaxCode = 1 << CodeSize;
263	ReadMask = MaxCode - 1;
264	FreeCode = FirstFree;
265	ByteOffset = BitOffset >> 3;
266	Code = rasterPtr[ByteOffset];
267
268	Code = rasterPtr[ByteOffset]
269	+ (((unsigned) rasterPtr[ByteOffset + 1]) << 8);
270	if (CodeSize >= 8)
271	Code += ((unsigned) rasterPtr[ByteOffset + 2]) << 16;
272
273	Code >>= BitOffset & 0x7;
274	BitOffset += CodeSize;
275	Code &= ReadMask;
276
277	CurCode = OldCode = Code;
278	FinChar = CurCode & BitMask;
279
280	_ADD_PIXEL (FinChar);
281	}
282	else {
283
284	CurCode = InCode = Code;
285
286	if (CurCode >= FreeCode) {
287
288	CurCode = OldCode;
289	OutCode[OutCount++] = FinChar;
290	}
291
292	while (CurCode > BitMask) {
293
294	if (OutCount > 1024)
295	goto _ExitReadError;
296
297	OutCode [OutCount++] = Suffix [CurCode];
298	CurCode = Prefix [CurCode];
299	}
300
301	FinChar = CurCode & BitMask;
302	OutCode [OutCount++] = FinChar;
303
304	for (i = OutCount - 1; i >= 0; --i)
305	_ADD_PIXEL (OutCode [i]);
306
307	OutCount = 0;
308	Prefix [FreeCode] = OldCode;
309	Suffix [FreeCode] = FinChar;
310	OldCode = InCode;
311	++FreeCode;
312
313	if (FreeCode >= MaxCode) {
314
315	if (CodeSize < 12) {
316
317	++CodeSize;
318	MaxCode <<= 1;
319	ReadMask = (1 << CodeSize) - 1;
320	}
321	}
322	}
323
324	ByteOffset = BitOffset >> 3;
325	Code = (unsigned) rasterPtr[ByteOffset];
326	Code = (unsigned) rasterPtr[ByteOffset]
327	+ (((unsigned) rasterPtr[ByteOffset + 1]) << 8);
328	if (CodeSize >= 8)
329	Code += ((unsigned) rasterPtr[ByteOffset + 2]) << 16;
330
331	Code >>= (BitOffset & 0x7);
332	BitOffset += CodeSize;
333	Code &= ReadMask;
334	}
335
336
337	/* Allocate the Image structure */
338	if (! (pximage = (XImage*) Xw_malloc(sizeof(XImage))))
339	goto _ExitAllocError;
340
341	/* Allocate the Extended Image structure */
342	if(! (pimage = Xw_add_imagedata_structure (sizeof(XW_EXT_IMAGEDATA))))
343	goto _ExitError;
344
345
346	/* Initialize the input image */
347	pimage->pimageinfo = aimageinfo;
348	_IIMAGE = pximage;
349	_IIMAGE->data = pidata;
350	_IIMAGE->width = (int) width;
351	_IIMAGE->height = (int) height;
352	_IIMAGE->xoffset = (int) 0;
353	_IIMAGE->format = (int) ZPixmap;
354	_IIMAGE->byte_order = (int) LSBFirst;
355	_IIMAGE->bitmap_unit = (int) 8;
356	_IIMAGE->bitmap_bit_order = (int) LSBFirst;
357	_IIMAGE->bitmap_pad = (int) 8;
358	_IIMAGE->depth = (int) 24;
359	_IIMAGE->bits_per_pixel = (int) 8;
360	_IIMAGE->bytes_per_line = (int) width;
361	_IIMAGE->red_mask = 0;
362	_IIMAGE->green_mask = 0;
363	_IIMAGE->blue_mask = 0;
364	_IIMAGE->obdata = NULL ;
365	_XInitImageFuncPtrs (_IIMAGE);
366
367
368	/* Return array of colors */
369	*ppcolors = pcolors;
370	*pncolors = ncolors;
371
372	if (wname) Xw_free(wname);
373
374
375	#ifdef DEBUG
376	fprintf (stderr, "\r\nXw_load_gif_image: Operation completed successfully.\r\n");
377	#endif /DEBUG/
378
379
380	/* Successfully loaded */
381
382	#ifdef PURIFY
383	if (rasterPtr) Xw_free (rasterPtr);
384	if (OutCode) Xw_free (OutCode);
385	if (Prefix) Xw_free (Prefix);
386	if (Suffix) Xw_free (Suffix);
387	#endif
388	return (pimage);
389
390
391
392	_ExitReadError:
393
394	/ERRORUnable to read Image data
395	Xw_set_error(61,"Xw_load_gif_image",filename);
396	*/
397	fprintf (stderr, "\r\nXw_load_gif_image: Error reading %s!", filename);
398	goto _ExitError;
399
400
401	_ExitAllocError:
402	/ERRORBad Image allocation
403	Xw_set_error(60,"Xw_load_gif_image",0);
404	*/
405	fprintf (stderr, "\r\nXw_load_gif_image: Error: Out of memory!");
406
407
408	_ExitError:
409
410	#ifdef DEB
411	fprintf (stderr, "\r\nXw_load_gif_image: An error occured! Returning NULL.");
412	#endif /DEB/
413
414	if (pchFileStream_start) Xw_free (pchFileStream_start);
415	if (pximage) Xw_free (pximage);
416	if (rasterPtr) Xw_free (rasterPtr);
417	if (pidata) Xw_free (pidata);
418	if (pimage) Xw_free (pidata);
419	if (pcolors) Xw_free (pcolors);
420	if (OutCode) Xw_free (OutCode);
421	if (Prefix) Xw_free (Prefix);
422	if (Suffix) Xw_free (Suffix);
423
424	return (NULL);
425	}
426
427	#undef _ADD_PIXEL