emacs: src/image.c comparison

comparison src/image.c @ 80545:d4410031dce7

(PIX_MASK_DRAW, PIX_MASK_RETAIN) [USE_MAC_IMAGE_IO]: New definitions for Image I/O support. (XGetImage, XPutPixel, XGetPixel, XDestroyImage) (mac_create_cg_image_from_image, x_create_x_image_and_pixmap) [USE_MAC_IMAGE_IO]: Add implementations for Image I/O support. (mac_data_provider_release_data, image_load_image_io) [USE_MAC_IMAGE_IO]: New functions. (CGImageCreateWithPNGDataProviderProcType) [MAC_OSX]: Remove typedef. (MyCGImageCreateWithPNGDataProvider) [MAC_OSX]: Remove variable. (init_image_func_pointer) [MAC_OSX]: Remove function. (image_load_quartz2d) [MAC_OSX]: Check availability of CGImageCreateWithPNGDataProvider at compile time. Use lowercase `false' for boolean constant. (png_load, jpeg_load, tiff_load, gif_load) [USE_MAC_IMAGE_IO]: Use image_load_image_io. (png_load) [!USE_MAC_IMAGE_IO && MAC_OSX]: Don't check MyCGImageCreateWithPNGDataProvider. (init_image) [MAC_OSX && TARGET_API_MAC_CARBON]: Don't call init_image_func_pointer.

author	YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
date	Fri, 02 May 2008 09:39:01 +0000
parents	296f5c781a2b
children	831994031d63

comparison

equal deleted inserted replaced

-:39cd9edb6ed7
+:d4410031dce7
 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
 #define NO_PIXMAP 0
 #define RGB_PIXEL_COLOR unsigned long
+#if USE_MAC_IMAGE_IO
+#define PIX_MASK_DRAW	255
+#define PIX_MASK_RETAIN	0
+#else
 /* A black pixel in a mask bitmap/pixmap means ``draw a source
 pixel''.  A white pixel means ``retain the current pixel''. */
 #define PIX_MASK_DRAW	RGB_TO_ULONG(0,0,0)
 #define PIX_MASK_RETAIN	RGB_TO_ULONG(255,255,255)
+#endif
 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
 #define x_defined_color mac_defined_color
 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
 int x, y;			/* not used */
 unsigned int width, height; /* not used */
 unsigned long plane_mask; 	/* not used */
 int format;		/* not used */
 {
+#if !USE_MAC_IMAGE_IO
 #if GLYPH_DEBUG
 xassert (x == 0 && y == 0);
 {
 Rect ri, rp;
 SetRect (&ri, 0, 0, width, height);
 }
 xassert (! (pixelsLocked & GetPixelsState (GetGWorldPixMap (pixmap))));
 #endif
 LockPixels (GetGWorldPixMap (pixmap));
+#endif
 return pixmap;
 }
 static void
 XPutPixel (ximage, x, y, pixel)
 XImagePtr ximage;
 int x, y;
 unsigned long pixel;
 {
+#if USE_MAC_IMAGE_IO
+if (ximage->bits_per_pixel == 32)
+((unsigned int *)(ximage->data + y * ximage->bytes_per_line))[x] = pixel;
+else
+((unsigned char *)(ximage->data + y * ximage->bytes_per_line))[x] = pixel;
+#else
 PixMapHandle pixmap = GetGWorldPixMap (ximage);
 short depth = GetPixDepth (pixmap);
 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
 if (depth == 32)
 SetCPixel (x, y, &color);
 SetGWorld (old_port, old_gdh);
 }
+#endif
 }
 static unsigned long
 XGetPixel (ximage, x, y)
 XImagePtr ximage;
 int x, y;
 {
+#if USE_MAC_IMAGE_IO
+if (ximage->bits_per_pixel == 32)
+return ((unsigned int *)(ximage->data + y * ximage->bytes_per_line))[x];
+else
+return ((unsigned char *)(ximage->data + y * ximage->bytes_per_line))[x];
+#else
 PixMapHandle pixmap = GetGWorldPixMap (ximage);
 short depth = GetPixDepth (pixmap);
 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
 if (depth == 32)
 GetCPixel (x, y, &color);
 SetGWorld (old_port, old_gdh);
 return RGB_TO_ULONG (color.red >> 8, color.green >> 8, color.blue >> 8);
 }
+#endif
 }
 static void
 XDestroyImage (ximg)
 XImagePtr ximg;
 {
+#if !USE_MAC_IMAGE_IO
 UnlockPixels (GetGWorldPixMap (ximg));
+#endif
 }
 #if USE_CG_DRAWING
+#if USE_MAC_IMAGE_IO
+void
+mac_data_provider_release_data (info, data, size)
+void *info;
+const void *data;
+size_t size;
+{
+xfree ((void *)data);
+}
+#endif
 static CGImageRef
 mac_create_cg_image_from_image (f, img)
 struct frame *f;
 struct image *img;
 {
+#if USE_MAC_IMAGE_IO
+XImagePtr ximg = img->pixmap;
+CGDataProviderRef provider;
+CGImageRef result;
+if (img->mask)
+{
+int x, y;
+unsigned long color, alpha;
+for (y = 0; y < ximg->height; y++)
+	for (x = 0; x < ximg->width; x++)
+	  {
+	    color = XGetPixel (ximg, x, y);
+	    alpha = XGetPixel (img->mask, x, y);
+	    XPutPixel (ximg, x, y,
+		       ARGB_TO_ULONG (alpha,
+				      RED_FROM_ULONG (color)
+				      * alpha / PIX_MASK_DRAW,
+				      GREEN_FROM_ULONG (color)
+				      * alpha / PIX_MASK_DRAW,
+				      BLUE_FROM_ULONG (color)
+				      * alpha / PIX_MASK_DRAW));
+	  }
+xfree (img->mask->data);
+img->mask->data = NULL;
+}
+BLOCK_INPUT;
+provider = CGDataProviderCreateWithData (NULL, ximg->data,
+					   ximg->bytes_per_line * ximg->height,
+					   mac_data_provider_release_data);
+ximg->data = NULL;
+result = CGImageCreate (ximg->width, ximg->height, 8, 32,
+			  ximg->bytes_per_line, mac_cg_color_space_rgb,
+			  (img->mask ? kCGImageAlphaPremultipliedFirst
+			   : kCGImageAlphaNoneSkipFirst)
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040
+			  | kCGBitmapByteOrder32Host
+#endif
+			  , provider, NULL, 0, kCGRenderingIntentDefault);
+CGDataProviderRelease (provider);
+UNBLOCK_INPUT;
+return result;
+#else
 Pixmap mask;
 CGImageRef result = NULL;
 BLOCK_INPUT;
 if (img->mask)
 	XFreePixmap (FRAME_X_DISPLAY (f), mask);
 }
 UNBLOCK_INPUT;
 return result;
+#endif
 }
 #endif /* USE_CG_DRAWING */
 #endif /* MAC_OS */
 *ximg = NULL;
 image_error ("Unable to create X pixmap", Qnil, Qnil);
 return 0;
 }
+#if !USE_MAC_IMAGE_IO
 LockPixels (GetGWorldPixMap (*pixmap));
+#endif
 *ximg = *pixmap;
 return 1;
 #endif  /* MAC_OS */
 }
 /***********************************************************************
 			MAC Image Load Functions
 ***********************************************************************/
+#if USE_MAC_IMAGE_IO
+static int
+image_load_image_io (f, img, type)
+struct frame *f;
+struct image *img;
+CFStringRef type;
+{
+CFDictionaryRef options, src_props = NULL, props = NULL;
+CFStringRef keys[2];
+CFTypeRef values[2];
+Lisp_Object specified_file, specified_data;
+CGImageSourceRef source = NULL;
+size_t count;
+CGImageRef image = NULL;
+int loop_count = -1;
+double delay_time = -1.0;
+int width, height;
+XImagePtr ximg = NULL;
+CGContextRef context;
+CGRect rectangle;
+int has_alpha_p, gif_p;
+gif_p = UTTypeEqual (type, kUTTypeGIF);
+keys[0] = kCGImageSourceTypeIdentifierHint;
+values[0] = (CFTypeRef) type;
+keys[1] = kCGImageSourceShouldCache;
+values[1] = (CFTypeRef) kCFBooleanFalse;
+options = CFDictionaryCreate (NULL, (const void **) keys,
+				(const void **) values,
+				sizeof (keys) / sizeof (keys[0]),
+				&kCFTypeDictionaryKeyCallBacks,
+				&kCFTypeDictionaryValueCallBacks);
+if (options == NULL)
+{
+image_error ("Error creating options for image `%s'", img->spec, Qnil);
+return 0;
+}
+/* Open the file.  */
+specified_file = image_spec_value (img->spec, QCfile, NULL);
+specified_data = image_spec_value (img->spec, QCdata, NULL);
+if (NILP (specified_data))
+{
+Lisp_Object file;
+CFStringRef path;
+CFURLRef url;
+file = x_find_image_file (specified_file);
+if (!STRINGP (file))
+	{
+	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
+	  return 0;
+	}
+path = cfstring_create_with_utf8_cstring (SDATA (file));
+if (path)
+	{
+	  url = CFURLCreateWithFileSystemPath (NULL, path,
+					       kCFURLPOSIXPathStyle, 0);
+	  CFRelease (path);
+	  if (url)
+	    {
+	      source = CGImageSourceCreateWithURL (url, NULL);
+	      CFRelease (url);
+	    }
+	}
+}
+else
+{
+CFDataRef data = CFDataCreate (NULL, SDATA (specified_data),
+				     SBYTES (specified_data));
+if (data)
+	{
+	  source = CGImageSourceCreateWithData (data, options);
+	  CFRelease (data);
+	}
+}
+CFRelease (options);
+if (source)
+{
+CFStringRef real_type = CGImageSourceGetType (source);
+if (real_type && UTTypeEqual (type, real_type))
+	src_props = CGImageSourceCopyProperties (source, NULL);
+if (src_props)
+	{
+	  EMACS_INT ino = 0;
+	  count = CGImageSourceGetCount (source);
+	  if (gif_p)
+	    {
+	      Lisp_Object image = image_spec_value (img->spec, QCindex, NULL);
+	      if (INTEGERP (image))
+		ino = XFASTINT (image);
+	    }
+	  if (ino >= 0 && ino < count)
+	    {
+	      props = CGImageSourceCopyPropertiesAtIndex (source, ino, NULL);
+	      if (props)
+		image = CGImageSourceCreateImageAtIndex (source, ino, NULL);
+	    }
+	}
+CFRelease (source);
+}
+if (image == NULL)
+{
+if (src_props)
+	CFRelease (src_props);
+if (props)
+	CFRelease (props);
+image_error ("Error reading image `%s'", img->spec, Qnil);
+return 0;
+}
+else
+{
+CFBooleanRef boolean;
+if (CFDictionaryGetValueIfPresent (props, kCGImagePropertyHasAlpha,
+					 (const void **) &boolean))
+	has_alpha_p = CFBooleanGetValue (boolean);
+if (gif_p)
+	{
+	  CFDictionaryRef dict;
+	  CFNumberRef number;
+	  dict = CFDictionaryGetValue (src_props,
+				       kCGImagePropertyGIFDictionary);
+	  if (dict
+	      && CFDictionaryGetValueIfPresent (dict,
+						kCGImagePropertyGIFLoopCount,
+						(const void **) &number))
+	    CFNumberGetValue (number, kCFNumberIntType, &loop_count);
+	  dict = CFDictionaryGetValue (props, kCGImagePropertyGIFDictionary);
+	  if (dict
+	      && CFDictionaryGetValueIfPresent (dict,
+						kCGImagePropertyGIFDelayTime,
+						(const void **) &number))
+	    CFNumberGetValue (number, kCFNumberDoubleType, &delay_time);
+	}
+CFRelease (src_props);
+CFRelease (props);
+}
+width = img->width = CGImageGetWidth (image);
+height = img->height = CGImageGetHeight (image);
+if (!check_image_size (f, width, height))
+{
+CGImageRelease (image);
+image_error ("Invalid image size", Qnil, Qnil);
+return 0;
+}
+if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
+{
+CGImageRelease (image);
+image_error ("Out of memory (%s)", img->spec, Qnil);
+return 0;
+}
+rectangle = CGRectMake (0, 0, width, height);
+context = CGBitmapContextCreate (ximg->data, ximg->width, ximg->height, 8,
+				   ximg->bytes_per_line,
+				   mac_cg_color_space_rgb,
+				   kCGImageAlphaNoneSkipFirst);
+if (has_alpha_p)
+{
+Lisp_Object specified_bg;
+XColor color;
+specified_bg = image_spec_value (img->spec, QCbackground, NULL);
+if (!STRINGP (specified_bg)
+	  || !mac_defined_color (f, SDATA (specified_bg), &color, 0))
+	{
+	  color.pixel = FRAME_BACKGROUND_PIXEL (f);
+	  color.red = RED16_FROM_ULONG (color.pixel);
+	  color.green = GREEN16_FROM_ULONG (color.pixel);
+	  color.blue = BLUE16_FROM_ULONG (color.pixel);
+	}
+CGContextSetRGBFillColor (context, color.red / 65535.0,
+				color.green / 65535.0,
+				color.blue / 65535.0, 1.0);
+CGContextFillRect (context, rectangle);
+}
+CGContextDrawImage (context, rectangle, image);
+CGContextRelease (context);
+CGImageRelease (image);
+/* Save GIF image extension data for `image-extension-data'.
+Format is (count IMAGES
+		0xff "NETSCAPE2.0" 0x00 DATA_SUB_BLOCK_FOR_LOOP_COUNT
+		0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK).  */
+if (gif_p)
+{
+img->data.lisp_val = Qnil;
+if (delay_time >= 0)
+	{
+	  Lisp_Object gce = make_uninit_string (4);
+	  int centisec = delay_time * 100.0 + 0.5;
+	  /* Fill the delay time field.  */
+	  SSET (gce, 1, centisec & 0xff);
+	  SSET (gce, 2, (centisec >> 8) & 0xff);
+	  /* We don't know about other fields.  */
+	  SSET (gce, 0, 0);
+	  SSET (gce, 3, 0);
+	  img->data.lisp_val = Fcons (make_number (0xf9),
+				      Fcons (gce,
+					     img->data.lisp_val));
+	}
+if (loop_count >= 0)
+	{
+	  Lisp_Object data_sub_block = make_uninit_string (3);
+	  SSET (data_sub_block, 0, 0x01);
+	  SSET (data_sub_block, 1, loop_count & 0xff);
+	  SSET (data_sub_block, 2, (loop_count >> 8) & 0xff);
+	  img->data.lisp_val = Fcons (make_number (0),
+				      Fcons (data_sub_block,
+					     img->data.lisp_val));
+	  img->data.lisp_val = Fcons (make_number (0xff),
+				      Fcons (build_string ("NETSCAPE2.0"),
+					     img->data.lisp_val));
+	}
+if (count > 1)
+	img->data.lisp_val = Fcons (Qcount,
+				    Fcons (make_number (count),
+					   img->data.lisp_val));
+}
+/* Maybe fill in the background field while we have ximg handy. */
+if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
+IMAGE_BACKGROUND (img, f, ximg);
+/* Put the image into the pixmap.  */
+x_put_x_image (f, ximg, img->pixmap, width, height);
+x_destroy_x_image (ximg);
+return 1;
+}
+#else  /* !USE_MAC_IMAGE_IO */
 static int image_load_quicktime P_ ((struct frame *, struct image *img,
 				     OSType));
 #ifdef MAC_OSX
 static int image_load_quartz2d P_ ((struct frame *, struct image *img, int));
 #endif
 }
 }
 #ifdef MAC_OSX
-/* Load a PNG/JPEG image using Quartz 2D decoding routines.
-CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
-So don't use this function directly but determine at runtime
-whether it exists. */
-typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType)
-(CGDataProviderRef, const float [], bool, CGColorRenderingIntent);
-static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider;
-static void
-init_image_func_pointer ()
-{
-if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
-{
-MyCGImageCreateWithPNGDataProvider
-	= (CGImageCreateWithPNGDataProviderProcType)
-	NSAddressOfSymbol (NSLookupAndBindSymbol
-			   ("_CGImageCreateWithPNGDataProvider"));
-}
-else
-MyCGImageCreateWithPNGDataProvider = NULL;
-}
 static int
 image_load_quartz2d (f, img, png_p)
 struct frame *f;
 struct image *img;
 int png_p;
 }
 else
 source = CGDataProviderCreateWithData (NULL, SDATA (specified_data),
 					   SBYTES (specified_data), NULL);
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
 if (png_p)
-image = (*MyCGImageCreateWithPNGDataProvider) (source, NULL, FALSE,
+image = CGImageCreateWithPNGDataProvider (source, NULL, false,
-						   kCGRenderingIntentDefault);
+					      kCGRenderingIntentDefault);
 else
-image = CGImageCreateWithJPEGDataProvider (source, NULL, FALSE,
+#endif
+image = CGImageCreateWithJPEGDataProvider (source, NULL, false,
 					       kCGRenderingIntentDefault);
 CGDataProviderRelease (source);
 if (image == NULL)
 {
 x_destroy_x_image (ximg);
 UNGCPRO;
 return 1;
 }
 #endif
+#endif	/* !USE_MAC_IMAGE_IO */
 #endif  /* MAC_OS */
 /***********************************************************************
 /* gnus-pointer.xpm uses '-' in its identifier.
 	 sb-dir-plus.xpm uses '+' in its identifier.  */
 if (isalpha (c) || c == '_' || c == '-' || c == '+')
 	{
 	  *beg = *s - 1;
-	  while (*s < end &&
+	  while (*s < end
-		 (c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))
+		 && (c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))
 	      ++*s;
 	  *len = *s - *beg;
 	  return XPM_TK_IDENT;
 	}
 else if (c == '"')
 static int
 png_load (f, img)
 struct frame *f;
 struct image *img;
 {
-#ifdef MAC_OSX
+#if USE_MAC_IMAGE_IO
-if (MyCGImageCreateWithPNGDataProvider)
+return image_load_image_io (f, img, kUTTypePNG);
-return image_load_quartz2d (f, img, 1);
+#elif MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
-else
+return image_load_quartz2d (f, img, 1);
+#else
+return image_load_quicktime (f, img, kQTFileTypePNG);
 #endif
-return image_load_quicktime (f, img, kQTFileTypePNG);
 }
 #endif  /* MAC_OS */
 #endif /* !HAVE_PNG */
 static int
 jpeg_load (f, img)
 struct frame *f;
 struct image *img;
 {
-#ifdef MAC_OSX
+#if USE_MAC_IMAGE_IO
+return image_load_image_io (f, img, kUTTypeJPEG);
+#elif defined (MAC_OSX)
 return image_load_quartz2d (f, img, 0);
 #else
 return image_load_quicktime (f, img, kQTFileTypeJPEG);
 #endif
 }
 static int
 tiff_load (f, img)
 struct frame *f;
 struct image *img;
 {
+#if USE_MAC_IMAGE_IO
+return image_load_image_io (f, img, kUTTypeTIFF);
+#else
 return image_load_quicktime (f, img, kQTFileTypeTIFF);
+#endif
 }
 #endif /* MAC_OS */
 #endif /* !HAVE_TIFF */
 static int
 gif_load (f, img)
 struct frame *f;
 struct image *img;
 {
+#if USE_MAC_IMAGE_IO
+return image_load_image_io (f, img, kUTTypeGIF);
+#else  /* !USE_MAC_IMAGE_IO */
 Lisp_Object specified_file, file;
 Lisp_Object specified_data;
 OSErr err;
 Boolean graphic_p, movie_p, prefer_graphic_p;
 Handle dh = NULL;
 goto error;
 }
 time_scale = GetMediaTimeScale (media);
 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
-if (!STRINGP (specified_bg) ||
+if (!STRINGP (specified_bg)
-!mac_defined_color (f, SDATA (specified_bg), &color, 0))
+|| !mac_defined_color (f, SDATA (specified_bg), &color, 0))
 {
 color.pixel = FRAME_BACKGROUND_PIXEL (f);
 color.red = RED16_FROM_ULONG (color.pixel);
 color.green = GREEN16_FROM_ULONG (color.pixel);
 color.blue = BLUE16_FROM_ULONG (color.pixel);
 if (movie)
 DisposeMovie (movie);
 if (dh)
 DisposeHandle (dh);
 return 0;
+#endif	/* !USE_MAC_IMAGE_IO */
 }
 #endif /* MAC_OS */
 #endif /* HAVE_GIF */
 }
 void
 init_image ()
 {
-#if defined (MAC_OSX) && TARGET_API_MAC_CARBON
-init_image_func_pointer ();
-#endif
 }
 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
 (do not change this comment) */

Mercurial > emacs

comparison src/image.c @ 80545:d4410031dce7