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

comparison src/glyphs-eimage.c @ 380:8626e4521993 r21-2-5

Import from CVS: tag r21-2-5

author	cvs
date	Mon, 13 Aug 2007 11:07:10 +0200
parents	6240c7796c7a
children	aabb7f5b1c81

comparison

equal deleted inserted replaced

-:76b7d63099ad
+:8626e4521993
 #include "glyphs.h"
 #include "objects.h"
 #include "buffer.h"
 #include "frame.h"
-#include "insdel.h"
 #include "opaque.h"
-#include "imgproc.h"
 #include "sysfile.h"
 #ifdef HAVE_PNG
 #ifdef __cplusplus
 extern "C" {
 #else
 #include <setjmp.h>
 #endif
 #ifdef FILE_CODING
 #include "file-coding.h"
-#endif
-#if INTBITS == 32
-# define FOUR_BYTE_TYPE unsigned int
-#elif LONGBITS == 32
-# define FOUR_BYTE_TYPE unsigned long
-#elif SHORTBITS == 32
-# define FOUR_BYTE_TYPE unsigned short
-#else
-#error What kind of strange-ass system are we running on?
 #endif
 #ifdef HAVE_TIFF
 DEFINE_IMAGE_INSTANTIATOR_FORMAT (tiff);
 Lisp_Object Qtiff;
 }
 else
 {
 	/* we're relying on the jpeg driver to do any other conversions,
 	   or signal an error if the conversion isn't supported. */
 	cinfo.out_color_space = JCS_RGB;
 }
 /* Step 5: Start decompressor */
 jpeg_start_decompress (&cinfo);
 	  (void) jpeg_read_scanlines (&cinfo, row_buffer, 1);
 	  jp = row_buffer[0];
 	  for (i = 0; i < cinfo.output_width; i++)
 	    {
 	      int clr;
 	      if (jpeg_gray)
 		{
 		  unsigned char val;
 #if (BITS_IN_JSAMPLE == 8)
 		  val = (unsigned char)*jp++;
 #else /* other option is 12 */
 }
 }
 /* Step 6.5: Create the pixmap and set up the image instance */
 /* now instantiate */
 MAYBE_DEVMETH (XDEVICE (ii->device),
 		 init_image_instance_from_eimage,
 		 (ii, cinfo.output_width, cinfo.output_height,
 		  unwind.eimage, dest_mask,
 		  instantiator, domain));
 /* Step 7: Finish decompression */
 jpeg_finish_decompress (&cinfo);
 static size_t
 gif_read_from_memory(GifByteType *buf, size_t size, VoidPtr data)
 {
 gif_memory_storage *mem = (gif_memory_storage*)data;
 if (size > (mem->len - mem->index))
-return -1;
+return (size_t) -1;
 memcpy(buf, mem->bytes + mem->index, size);
 mem->index = mem->index + size;
 return size;
 }
 struct gif_error_struct gif_err;
 Extbyte *bytes;
 Extcount len;
 int height = 0;
 int width = 0;
 xzero (unwind);
 record_unwind_protect (gif_instantiate_unwind, make_opaque_ptr (&unwind));
 /* 1. Now decode the data. */
 {
 Lisp_Object data = find_keyword_in_vector (instantiator, Q_data);
 assert (!NILP (data));
 if (!(unwind.giffile = GifSetup()))
 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
 	   for us.  Just pass the error along. */
 	Lisp_Object errstring;
 	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);
 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);
 DGifInitRead(unwind.giffile);
 /* Then slurp the image into memory, decoding along the way.
 The result is the image in a simple one-byte-per-pixel
 format (#### the GIF routines only support 8-bit GIFs,
 it appears). */
 DGifSlurp (unwind.giffile);
 }
 /* 3. Now create the EImage */
 {
 ColorMapObject *cmo = unwind.giffile->SColorMap;
 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*) xmalloc (width * height * 3);
 if (!unwind.eimage)
 signal_image_error("Unable to allocate enough memory for image", instantiator);
 /* write the data in EImage format (8bit RGB triples) */
 /* 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++)
 {
 	if (interlace)
 	  if (row >= height) {
 	    row = InterlacedOffset[++pass];
 	    while (row > height)
 	      row = InterlacedOffset[++pass];
 	  }
 	eip = unwind.eimage + (row * width * 3);
 	for (j = 0; j < width; j++)
 	  {
 	  }
 	row += interlace ? InterlacedJumps[pass] : 1;
 }
 }
 /* now instantiate */
 MAYBE_DEVMETH (XDEVICE (ii->device),
 		 init_image_instance_from_eimage,
 		 (ii, width, height, unwind.eimage, dest_mask,
 		  instantiator, domain));
 unbind_to (speccount, Qnil);
 }
 #endif /* HAVE_GIF */
 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
-between inside the libarary, and inside the code!  To do an end run
+between inside the library, and inside the code!  To do an end run
 around this, use our own error functions, and don't rely on things
 passed in the png_ptr to them.  This is an ugly hack and must
 go away when the lisp engine is threaded! */
 static struct png_error_struct png_err_stct;
 if (!info_ptr)
 {
 png_destroy_read_struct (&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
 signal_image_error ("Error obtaining memory for png_read", instantiator);
 }
 xzero (unwind);
 unwind.png_ptr = png_ptr;
 unwind.info_ptr = info_ptr;
 record_unwind_protect (png_instantiate_unwind, make_opaque_ptr (&unwind));
 */
 /* It has been further modified to handle the API changes for 0.96,
 and is no longer usable for previous versions. jh
 */
-/* Set the jmp_buf reurn context for png_error ... if this returns !0, then
+/* Set the jmp_buf return context for png_error ... if this returns !0, then
 we ran into a problem somewhere, and need to clean up after ourselves. */
 if (setjmp (png_err_stct.setjmp_buffer))
 {
 /* Something blew up: just display the error (cleanup happens in the unwind) */
 signal_image_error_2 ("Error decoding PNG",
 /* Wow, allocate all the memory.  Truly, exciting. */
 unwind.eimage = xnew_array_and_zero (unsigned char, width * height * 3);
 /* libpng expects that the image buffer passed in contains a
 picture to draw on top of if the png has any transparencies.
 This could be a good place to pass that in... */
 row_pointers  = xnew_array (png_byte *, height);
 for (y = 0; y < height; y++)
 row_pointers[y] = unwind.eimage + (width * 3 * y);
 					(c));
 	  my_background.red = XINT (XCAR (rgblist));
 	  my_background.green = XINT (XCAR (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);
 else
 	png_set_background (png_ptr, &my_background,
 			    PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
 }
 /* Now that we're using EImage, ask for 8bit RGB triples for any type
 of image*/
-/* convert palatte images to full RGB */
+/* convert palette images to full RGB */
 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 png_set_expand (png_ptr);
 /* send grayscale images to RGB too */
 if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY ||
 info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 	  png_set_packing (png_ptr);
 }
 png_read_image (png_ptr, row_pointers);
 png_read_end (png_ptr, info_ptr);
 #ifdef PNG_SHOW_COMMENTS
 /* ####
 * I turn this off by default now, because the !%^@#!% comments
 * show up every time the image is instantiated, which can get
 * really really annoying.  There should be some way to pass this
 xfree (row_pointers);
 }
 /* now instantiate */
 MAYBE_DEVMETH (XDEVICE (ii->device),
 		 init_image_instance_from_eimage,
 		 (ii, width, height, unwind.eimage, dest_mask,
 		  instantiator, domain));
 /* This will clean up everything else. */
 unbind_to (speccount, Qnil);
 }
 return -1;
 }
 if ((newidx > mem->len) || (newidx < 0))
 return -1;
 mem->index = newidx;
 return newidx;
 }
 static int
 int speccount = specpdl_depth ();
 uint32 width, height;
 xzero (unwind);
 record_unwind_protect (tiff_instantiate_unwind, make_opaque_ptr (&unwind));
 /* set up error facilities */
 if (setjmp (tiff_err_data.setjmp_buffer))
 {
 /* An error was signaled. No clean up is needed, as unwind handles that
 	 for us.  Just pass the error along. */
 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.
-It needs to be reimplimented via scanline reads for both memory
+It needs to be reimplemented via scanline reads for both memory
 compactness. */
 raster = (uint32*) _TIFFmalloc (width * height * sizeof (uint32));
 if (raster != NULL)
 {
 	int i,j;
 	signal_image_error ("Unable to allocate memory for TIFFReadRGBA", instantiator);
 }
 /* now instantiate */
 MAYBE_DEVMETH (XDEVICE (ii->device),
 		 init_image_instance_from_eimage,
 		 (ii, width, height, unwind.eimage, dest_mask,
 		  instantiator, domain));
 unbind_to (speccount, Qnil);
 }

Mercurial > hg > xemacs-beta

comparison src/glyphs-eimage.c @ 380:8626e4521993 r21-2-5