xemacs-beta: src/glyphs-eimage.c comparison

comparison src/glyphs-eimage.c @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14

author	cvs
date	Mon, 13 Aug 2007 11:20:41 +0200
parents	501cfd01ee6d
children	11054d720c21

comparison

equal deleted inserted replaced

-:12e008d41344
+:697ef44129c6
 #include "objects.h"
 #include "buffer.h"
 #include "frame.h"
 #include "opaque.h"
-#include "window.h"
 #include "sysfile.h"
 #ifdef HAVE_PNG
 #ifdef __cplusplus
 static void
 jpeg_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		  Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		  int dest_mask, Lisp_Object domain)
 {
-Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 /* It is OK for the unwind data to be local to this function,
 because the unwind-protect is always executed when this
 stack frame is still valid. */
 struct jpeg_unwind_data unwind;
 int speccount = specpdl_depth ();
 /* Step 2: specify data source (eg, a file) */
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-const Extbyte *bytes;
+CONST Extbyte *bytes;
 Extcount len;
 /* #### This is a definite problem under Mule due to the amount of
 stack data it might allocate.  Need to be able to convert and
 write out to a file. */
-TO_EXTERNAL_FORMAT (LISP_STRING, data, ALLOCA, (bytes, len), Qbinary);
+GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 jpeg_memory_src (&cinfo, (JOCTET *) bytes, len);
 }
 /* Step 3: read file parameters with jpeg_read_header() */
 }
 }
 /* Step 6.5: Create the pixmap and set up the image instance */
 /* now instantiate */
-MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain),
+MAYBE_DEVMETH (XDEVICE (ii->device),
 		 init_image_instance_from_eimage,
-		 (ii, cinfo.output_width, cinfo.output_height, 1,
+		 (ii, cinfo.output_width, cinfo.output_height,
 		  unwind.eimage, dest_mask,
 		  instantiator, domain));
 /* Step 7: Finish decompression */
 return 0;
 }
 struct gif_error_struct
 {
-const char *err_str;		/* return the error string */
+CONST char *err_str;		/* return the error string */
 jmp_buf setjmp_buffer;	/* for return to caller */
 };
 static void
-gif_error_func(const char *err_str, VoidPtr error_ptr)
+gif_error_func(CONST char *err_str, VoidPtr error_ptr)
 {
 struct gif_error_struct *error_data = (struct gif_error_struct*)error_ptr;
 /* return to setjmp point */
 error_data->err_str = err_str;
 static void
 gif_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		 int dest_mask, Lisp_Object domain)
 {
-Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 /* It is OK for the unwind data to be local to this function,
 because the unwind-protect is always executed when this
 stack frame is still valid. */
 struct gif_unwind_data unwind;
 int speccount = specpdl_depth ();
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 assert (!NILP (data));
 if (!(unwind.giffile = GifSetup()))
-signal_image_error ("Insufficient memory to instantiate GIF image", instantiator);
+signal_image_error ("Insufficent memory to instantiate GIF image", instantiator);
 /* set up error facilities */
 if (setjmp(gif_err.setjmp_buffer))
 {
 	/* An error was signaled. No clean up is needed, as unwind handles that
 	errstring = build_string (gif_err.err_str);
 	signal_image_error_2 ("GIF decoding error", errstring, instantiator);
 }
 GifSetErrorFunc(unwind.giffile, (Gif_error_func)gif_error_func, (VoidPtr)&gif_err);
-TO_EXTERNAL_FORMAT (LISP_STRING, data, ALLOCA, (bytes, len), Qbinary);
+GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 mem_struct.bytes = bytes;
 mem_struct.len = len;
 mem_struct.index = 0;
 GifSetReadFunc(unwind.giffile, gif_read_from_memory, (VoidPtr)&mem_struct);
 GifSetCloseFunc(unwind.giffile, gif_memory_close, (VoidPtr)&mem_struct);
 format (#### the GIF routines only support 8-bit GIFs,
 it appears). */
 DGifSlurp (unwind.giffile);
 }
-/* 3. Now create the EImage(s) */
+/* 3. Now create the EImage */
 {
 ColorMapObject *cmo = unwind.giffile->SColorMap;
-int i, j, row, pass, interlace, slice;
+int i, j, row, pass, interlace;
 unsigned char *eip;
 /* interlaced gifs have rows in this order:
 0, 8, 16, ..., 4, 12, 20, ..., 2, 6, 10, ..., 1, 3, 5, ...  */
 static int InterlacedOffset[] = { 0, 4, 2, 1 };
 static int InterlacedJumps[] = { 8, 8, 4, 2 };
 height = unwind.giffile->SHeight;
 width = unwind.giffile->SWidth;
-unwind.eimage = (unsigned char*)
+unwind.eimage = (unsigned char*) xmalloc (width * height * 3);
-xmalloc (width * height * 3 * unwind.giffile->ImageCount);
 if (!unwind.eimage)
 signal_image_error("Unable to allocate enough memory for image", instantiator);
 /* write the data in EImage format (8bit RGB triples) */
-for (slice = 0; slice < unwind.giffile->ImageCount; slice++)
+/* Note: We just use the first image in the file and ignore the rest.
+We check here that that image covers the full "screen" size.
+I don't know whether that's always the case.
+-dkindred@cs.cmu.edu  */
+if (unwind.giffile->SavedImages[0].ImageDesc.Height != height
+	|| unwind.giffile->SavedImages[0].ImageDesc.Width != width
+	|| unwind.giffile->SavedImages[0].ImageDesc.Left != 0
+	|| unwind.giffile->SavedImages[0].ImageDesc.Top != 0)
+signal_image_error ("First image in GIF file is not full size",
+			  instantiator);
+interlace = unwind.giffile->SavedImages[0].ImageDesc.Interlace;
+pass = 0;
+row = interlace ? InterlacedOffset[pass] : 0;
+eip = unwind.eimage;
+for (i = 0; i < height; i++)
 {
-	/* We check here that that the current image covers the full "screen" size. */
+	if (interlace)
-	if (unwind.giffile->SavedImages[slice].ImageDesc.Height != height
+	  if (row >= height) {
-	    || unwind.giffile->SavedImages[slice].ImageDesc.Width != width
+	    row = InterlacedOffset[++pass];
-	    || unwind.giffile->SavedImages[slice].ImageDesc.Left != 0
+	    while (row >= height)
-	    || unwind.giffile->SavedImages[slice].ImageDesc.Top != 0)
+	      row = InterlacedOffset[++pass];
-	  signal_image_error ("Image in GIF file is not full size",
+	  }
-			      instantiator);
+	eip = unwind.eimage + (row * width * 3);
+	for (j = 0; j < width; j++)
-	interlace = unwind.giffile->SavedImages[slice].ImageDesc.Interlace;
-	pass = 0;
-	row = interlace ? InterlacedOffset[pass] : 0;
-	eip = unwind.eimage + (width * height * 3 * slice);
-	for (i = 0; i < height; i++)
 	  {
-	    if (interlace)
+	    unsigned char pixel = unwind.giffile->SavedImages[0].RasterBits[(i * width) + j];
-	      if (row >= height) {
+	    *eip++ = cmo->Colors[pixel].Red;
-		row = InterlacedOffset[++pass];
+	    *eip++ = cmo->Colors[pixel].Green;
-		while (row >= height)
+	    *eip++ = cmo->Colors[pixel].Blue;
-		  row = InterlacedOffset[++pass];
-	      }
-	    eip = unwind.eimage + (width * height * 3 * slice) + (row * width * 3);
-	    for (j = 0; j < width; j++)
-	      {
-		unsigned char pixel =
-		  unwind.giffile->SavedImages[slice].RasterBits[(i * width) + j];
-		*eip++ = cmo->Colors[pixel].Red;
-		*eip++ = cmo->Colors[pixel].Green;
-		*eip++ = cmo->Colors[pixel].Blue;
-	      }
-	    row += interlace ? InterlacedJumps[pass] : 1;
 	  }
+	row += interlace ? InterlacedJumps[pass] : 1;
 }
-/* now instantiate */
-MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain),
-		   init_image_instance_from_eimage,
-		   (ii, width, height, unwind.giffile->ImageCount, unwind.eimage, dest_mask,
-		    instantiator, domain));
 }
+/* now instantiate */
-/* We read the gif successfully. If we have more than one slice then
+MAYBE_DEVMETH (XDEVICE (ii->device),
-animate the gif. */
+		 init_image_instance_from_eimage,
-if (unwind.giffile->ImageCount > 1)
+		 (ii, width, height, unwind.eimage, dest_mask,
-{
+		  instantiator, domain));
-/* See if there is a timeout value. In theory there could be one
-for every image - but that makes the implementation way to
-complicated for now so we just take the first. */
-unsigned short timeout = 0;
-Lisp_Object tid;
-if (unwind.giffile->SavedImages[0].Function == GRAPHICS_EXT_FUNC_CODE
-	  &&
-	  unwind.giffile->SavedImages[0].ExtensionBlockCount)
-	{
-	  timeout = (unsigned short)
-	    ((unwind.giffile->SavedImages[0].ExtensionBlocks[0].Bytes[2] << 8) +
-	     unwind.giffile-> SavedImages[0].ExtensionBlocks[0].Bytes[1]) * 10;
-	}
-/* Too short a timeout will crucify us performance-wise. */
-tid = add_glyph_animated_timeout (timeout > 10 ? timeout : 10, image_instance);
-if (!NILP (tid))
-	IMAGE_INSTANCE_PIXMAP_TIMEOUT (ii) = XINT (tid);
-}
 unbind_to (speccount, Qnil);
 }
 #endif /* HAVE_GIF */
 return IMAGE_COLOR_PIXMAP_MASK;
 }
 struct png_memory_storage
 {
-const Extbyte *bytes;		/* The data       */
+CONST Extbyte *bytes;		/* The data       */
 Extcount len;			/* How big is it? */
 int index;			/* Where are we?  */
 };
 static void
 tbr->index = tbr->index + length;
 }
 struct png_error_struct
 {
-const char *err_str;
+CONST char *err_str;
 jmp_buf setjmp_buffer;	/* for return to caller */
 };
 /* jh 98/03/12 - #### AARRRGH! libpng includes jmp_buf inside its own
 structure, and there are cases where the size can be different from
 static void
 png_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		 int dest_mask, Lisp_Object domain)
 {
-Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 struct png_unwind_data unwind;
 int speccount = specpdl_depth ();
 int height, width;
 struct png_memory_storage tbr;  /* Data to be read */
 }
 /* Initialize the IO layer and read in header information */
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
-const Extbyte *bytes;
+CONST Extbyte *bytes;
 Extcount len;
 assert (!NILP (data));
 /* #### This is a definite problem under Mule due to the amount of
 stack data it might allocate.  Need to think about using Lstreams */
-TO_EXTERNAL_FORMAT (LISP_STRING, data, ALLOCA, (bytes, len), Qbinary);
+GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
 tbr.bytes = bytes;
 tbr.len = len;
 tbr.index = 0;
 png_set_read_fn (png_ptr,(void *) &tbr, png_read_from_memory);
 }
 	{
 	  warn_when_safe (Qpng, Qinfo, "Couldn't get background color!");
 	}
 else
 	{
-	  Lisp_Color_Instance *c;
+	  struct Lisp_Color_Instance *c;
 	  Lisp_Object rgblist;
 	  c = XCOLOR_INSTANCE (bkgd);
 	  rgblist = MAYBE_LISP_DEVMETH (XDEVICE (c->device),
 					color_instance_rgb_components,
 					(c));
-	  my_background.red = (unsigned short) XINT (XCAR (rgblist));
+	  my_background.red = XINT (XCAR (rgblist));
-	  my_background.green = (unsigned short) XINT (XCAR (XCDR (rgblist)));
+	  my_background.green = XINT (XCAR (XCDR (rgblist)));
-	  my_background.blue = (unsigned short) XINT (XCAR (XCDR (XCDR (rgblist))));
+	  my_background.blue = XINT (XCAR (XCDR (XCDR (rgblist))));
 	}
 if (png_get_bKGD (png_ptr, info_ptr, &image_background))
 	png_set_background (png_ptr, image_background,
 			    PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
 xfree (row_pointers);
 }
 /* now instantiate */
-MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain),
+MAYBE_DEVMETH (XDEVICE (ii->device),
 		 init_image_instance_from_eimage,
-		 (ii, width, height, 1, unwind.eimage, dest_mask,
+		 (ii, width, height, unwind.eimage, dest_mask,
 		  instantiator, domain));
 /* This will clean up everything else. */
 unbind_to (speccount, Qnil);
 }
 return mem->len;
 }
 struct tiff_error_struct
 {
-#ifdef HAVE_VSNPRINTF
+#if HAVE_VSNPRINTF
 char err_str[256];
 #else
 char err_str[1024];		/* return the error string */
 #endif
 jmp_buf setjmp_buffer;	/* for return to caller */
 have any place to store error func data.  This should be rectified
 before XEmacs gets threads! */
 static struct tiff_error_struct tiff_err_data;
 static void
-tiff_error_func(const char *module, const char *fmt, ...)
+tiff_error_func(CONST char *module, CONST char *fmt, ...)
 {
 va_list vargs;
 va_start (vargs, fmt);
-#ifdef HAVE_VSNPRINTF
+#if HAVE_VSNPRINTF
 vsnprintf (tiff_err_data.err_str, 255, fmt, vargs);
 #else
 /* pray this doesn't overflow... */
 vsprintf (tiff_err_data.err_str, fmt, vargs);
 #endif
 /* return to setjmp point */
 longjmp (tiff_err_data.setjmp_buffer, 1);
 }
 static void
-tiff_warning_func(const char *module, const char *fmt, ...)
+tiff_warning_func(CONST char *module, CONST char *fmt, ...)
 {
 va_list vargs;
-#ifdef HAVE_VSNPRINTF
+#if HAVE_VSNPRINTF
 char warn_str[256];
 #else
 char warn_str[1024];
 #endif
 va_start (vargs, fmt);
-#ifdef HAVE_VSNPRINTF
+#if HAVE_VSNPRINTF
 vsnprintf (warn_str, 255, fmt, vargs);
 #else
 vsprintf (warn_str, fmt, vargs);
 #endif
 va_end (vargs);
 static void
 tiff_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
 		  Lisp_Object pointer_fg, Lisp_Object pointer_bg,
 		  int dest_mask, Lisp_Object domain)
 {
-Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
+struct Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance);
 tiff_memory_storage mem_struct;
 /* It is OK for the unwind data to be local to this function,
 because the unwind-protect is always executed when this
 stack frame is still valid. */
 struct tiff_unwind_data unwind;
 assert (!NILP (data));
 /* #### This is a definite problem under Mule due to the amount of
 stack data it might allocate.  Think about Lstreams... */
-TO_EXTERNAL_FORMAT (LISP_STRING, data,
+GET_STRING_BINARY_DATA_ALLOCA (data, bytes, len);
-			ALLOCA, (bytes, len),
-			Qbinary);
 mem_struct.bytes = bytes;
 mem_struct.len = len;
 mem_struct.index = 0;
 unwind.tiff = TIFFClientOpen ("memfile", "r", &mem_struct,
 				  (TIFFReadWriteProc)tiff_memory_read,
 				  (TIFFReadWriteProc)tiff_memory_write,
 				  tiff_memory_seek, tiff_memory_close, tiff_memory_size,
 				  tiff_map_noop, tiff_unmap_noop);
 if (!unwind.tiff)
-signal_image_error ("Insufficient memory to instantiate TIFF image", instantiator);
+signal_image_error ("Insufficent memory to instantiate TIFF image", instantiator);
 TIFFGetField (unwind.tiff, TIFFTAG_IMAGEWIDTH, &width);
 TIFFGetField (unwind.tiff, TIFFTAG_IMAGELENGTH, &height);
 unwind.eimage = (unsigned char *) xmalloc (width * height * 3);
-/* #### This is little more than proof-of-concept/function testing.
+/* ### This is little more than proof-of-concept/function testing.
 It needs to be reimplemented via scanline reads for both memory
 compactness. */
 raster = (uint32*) _TIFFmalloc (width * height * sizeof (uint32));
 if (raster != NULL)
 {
 	signal_image_error ("Unable to allocate memory for TIFFReadRGBA", instantiator);
 }
 /* now instantiate */
-MAYBE_DEVMETH (DOMAIN_XDEVICE (ii->domain),
+MAYBE_DEVMETH (XDEVICE (ii->device),
 		 init_image_instance_from_eimage,
-		 (ii, width, height, 1, unwind.eimage, dest_mask,
+		 (ii, width, height, unwind.eimage, dest_mask,
 		  instantiator, domain));
 unbind_to (speccount, Qnil);
 }

Mercurial > hg > xemacs-beta

comparison src/glyphs-eimage.c @ 412:697ef44129c6 r21-2-14