From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: joakim@verona.se Newsgroups: gmane.emacs.devel Subject: Re: SVG support(again) ? Date: Sat, 18 Aug 2007 13:44:57 +0200 Message-ID: References: NNTP-Posting-Host: lo.gmane.org Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-Trace: sea.gmane.org 1187437515 32464 80.91.229.12 (18 Aug 2007 11:45:15 GMT) X-Complaints-To: usenet@sea.gmane.org NNTP-Posting-Date: Sat, 18 Aug 2007 11:45:15 +0000 (UTC) To: emacs-devel Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Sat Aug 18 13:45:13 2007 Return-path: Envelope-to: ged-emacs-devel@m.gmane.org Original-Received: from lists.gnu.org ([199.232.76.165]) by lo.gmane.org with esmtp (Exim 4.50) id 1IMMjv-0005vn-5j for ged-emacs-devel@m.gmane.org; Sat, 18 Aug 2007 13:45:11 +0200 Original-Received: from localhost ([127.0.0.1] helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1IMMju-0000OC-Ei for ged-emacs-devel@m.gmane.org; Sat, 18 Aug 2007 07:45:10 -0400 Original-Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1IMMjq-0000NB-8z for emacs-devel@gnu.org; Sat, 18 Aug 2007 07:45:06 -0400 Original-Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1IMMjn-0000Mn-5p for emacs-devel@gnu.org; Sat, 18 Aug 2007 07:45:05 -0400 Original-Received: from [199.232.76.173] (helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1IMMjn-0000Mk-09 for emacs-devel@gnu.org; Sat, 18 Aug 2007 07:45:03 -0400 Original-Received: from proxy1.bredband.net ([195.54.101.71]) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1IMMjm-00079r-DW for emacs-devel@gnu.org; Sat, 18 Aug 2007 07:45:02 -0400 Original-Received: from kurono.home (83.227.131.3) by proxy1.bredband.net (7.3.127) id 46C6D33500001119 for emacs-devel@gnu.org; Sat, 18 Aug 2007 13:44:57 +0200 In-Reply-To: (Richard Stallman's message of "Thu\, 16 Aug 2007 20\:32\:00 -0400") User-Agent: Gnus/5.110006 (No Gnus v0.6) Emacs/22.1.50 (gnu/linux) X-Detected-Kernel: Genre and OS details not recognized. X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Original-Sender: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Xref: news.gmane.org gmane.emacs.devel:76720 Archived-At: Richard Stallman writes: > /* Structure describing the image type `svg'. */ > > static struct image_type svg_type = > { > &Qsvg, > svg_image_p, > svg_load, > x_clear_image, > NULL > }; > > How about adding another comment for each field explaining what > the field means and why this particular value is used. > > /* DEF_IMGLIB_FN() here? */ > > I don't understand that comment -- if you do, could you make > it less terse, and clear? > > /* helper function for svg_load, does the actual loading > given contents and size, apart from frame and image structures, passed from svg_load > > Uses librsvg to do most of the image processing. > > Returns non-zero when sucessful > */ > > That is terse and cryptic. Could you rewrite it to be clear > and format it the way we like to do? > > The code of svg_load_image needs more comments explaining what the > parts of the code do. Here is a new try. I believe this is quite readable now. Note that some of the difficulty in understanding this code comes from reading it in isolation from the other code im image.c. I tried adding some helpful pointers to other emacs code. /*********************************************************************** SVG ***********************************************************************/ #if defined (HAVE_RSVG) /* Function prototypes. */ static int svg_image_p P_ ((Lisp_Object object)); static int svg_load P_ ((struct frame *f, struct image *img)); static int svg_load_image P_ ((struct frame *, struct image *, unsigned char *, unsigned int)); /* The symbol `svg' identifying images of this type. */ Lisp_Object Qsvg; /* Indices of image specification fields in svg_format, below. */ enum svg_keyword_index { SVG_TYPE, SVG_DATA, SVG_FILE, SVG_ASCENT, SVG_MARGIN, SVG_RELIEF, SVG_ALGORITHM, SVG_HEURISTIC_MASK, SVG_MASK, SVG_BACKGROUND, SVG_LAST }; /* Vector of image_keyword structures describing the format of valid user-defined image specifications. */ static struct image_keyword svg_format[SVG_LAST] = { {":type", IMAGE_SYMBOL_VALUE, 1}, {":data", IMAGE_STRING_VALUE, 0}, {":file", IMAGE_STRING_VALUE, 0}, {":ascent", IMAGE_ASCENT_VALUE, 0}, {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0}, {":relief", IMAGE_INTEGER_VALUE, 0}, {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0}, {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}, {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}, {":background", IMAGE_STRING_OR_NIL_VALUE, 0} }; /* Structure describing the image type `svg'. Its the same type of structure defined for all image formats, handled by emacs image functions. see struct image_type in dispextern.h */ static struct image_type svg_type = { &Qsvg, /* an identifier showing that this is an image structure for the SVG format*/ svg_image_p, /* handle to a function that can be used to identify a svg file*/ svg_load, /* handle to function used to load a svg file*/ x_clear_image,/* handle to function to free sresources for SVG*/ NULL /* an internal field to link to the next image type in a list of image types, will be filled in when registering the format*/ }; /* Return non-zero if OBJECT is a valid SVG image specification. do this by calling parse_image_spec and supplying the keywords that identify the SVG format */ static int svg_image_p (object) Lisp_Object object; { struct image_keyword fmt[SVG_LAST]; bcopy (svg_format, fmt, sizeof fmt); if (!parse_image_spec (object, fmt, SVG_LAST, Qsvg)) return 0; /* Must specify either the :data or :file keyword. */ return fmt[SVG_FILE].count + fmt[SVG_DATA].count == 1; } #include /* DEF_IMGLIB_FN() here in the future. this macro is used to handle loading of dynamic link library functions for various OS:es. currently only librsvg2 is supportedd, which is only available for X, so its not strictly necessary yet. The current code is thought to be compatible with this scheme because of the defines below, should librsvg2 become available on more plattforms. */ #define fn_rsvg_handle_new rsvg_handle_new #define fn_rsvg_handle_set_size_callback rsvg_handle_set_size_callback #define fn_rsvg_handle_write rsvg_handle_write #define fn_rsvg_handle_close rsvg_handle_close #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf #define fn_rsvg_handle_free rsvg_handle_free #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample /* Load SVG image IMG for use on frame F. Value is non-zero if successful. this function wil go into the svg_type structure, and the prototype thus needs to be compatible with that structure */ static int svg_load (f, img) struct frame *f; struct image *img; { int success_p = 0; Lisp_Object file_name; /* If IMG->spec specifies a file name, create a non-file spec from it. */ file_name = image_spec_value (img->spec, QCfile, NULL); if (STRINGP (file_name)) { Lisp_Object file; unsigned char *contents; int size; struct gcpro gcpro1; file = x_find_image_file (file_name); GCPRO1 (file); if (!STRINGP (file)) { image_error ("Cannot find image file `%s'", file_name, Qnil); UNGCPRO; return 0; } contents = slurp_file (SDATA (file), &size); /* read the entire file into memory*/ if (contents == NULL) { image_error ("Error loading SVG image `%s'", img->spec, Qnil); UNGCPRO; return 0; } success_p = svg_load_image (f, img, contents, size); /* if the file was slurped into memory properly, parse it*/ xfree (contents); UNGCPRO; } else/*its not a file, its a lisp object*/ { Lisp_Object data; data = image_spec_value (img->spec, QCdata, NULL); success_p = svg_load_image (f, img, SDATA (data), SBYTES (data)); } return success_p; } /* helper function for svg_load, does the actual loading given contents and size, apart from frame and image structures, passed from svg_load Uses librsvg to do most of the image processing. Returns non-zero when sucessful */ static int svg_load_image (f, img, contents, size) struct frame *f; struct image *img; unsigned char *contents; unsigned int size; { RsvgHandle *rsvg_handle; GError *error = NULL; GdkPixbuf *pixbuf; int width; int height; const guint8 *pixels; int rowstride; XImagePtr ximg; XColor background; int x; int y; g_type_init (); /*glib function that must be called prior to using gnome type library functions*/ rsvg_handle = fn_rsvg_handle_new ();/* make a handle to a new rsvg object*/ fn_rsvg_handle_write (rsvg_handle, contents, size, &error);/*parse "contents" and fill in the rsvg_handle*/ if (error) goto rsvg_error; fn_rsvg_handle_close (rsvg_handle, &error);/*the parsing is complete, rsvg_handle is ready to use*/ if (error) goto rsvg_error; pixbuf = fn_rsvg_handle_get_pixbuf (rsvg_handle);/* we can now get a valid pixel buffer from the svg file, if all went ok*/ eassert (pixbuf); /* extract some meta data from he svg handle*/ width = fn_gdk_pixbuf_get_width (pixbuf); height = fn_gdk_pixbuf_get_height (pixbuf); pixels = fn_gdk_pixbuf_get_pixels (pixbuf); rowstride = fn_gdk_pixbuf_get_rowstride (pixbuf); /*validate the svg meta data*/ eassert (fn_gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB); eassert (fn_gdk_pixbuf_get_n_channels (pixbuf) == 4); eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf)); eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf) == 8); /* try to create a x pixmap to hold the svg pixmap*/ if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap)) { g_object_unref (pixbuf); return 0; } init_color_table (); #ifdef HAVE_X_WINDOWS background.pixel = FRAME_BACKGROUND_PIXEL (f); x_query_color (f, &background); /* svg pixmaps specify transparency in the last byte, so right shift 8 bits to get rid of it, since emacs doesnt support transparency*/ background.red >>= 8; background.green >>= 8; background.blue >>= 8; #else /* not HAVE_X_WINDOWS */ #error FIXME #endif /* this loop handles opacity values, since emacs assumes non-transparent images. Each pixel must be "flattened" by calculating he resulting color, given the transparency of the pixel, and the image background color. */ for (y = 0; y < height; ++y) { for (x = 0; x < width; ++x) { unsigned red; unsigned green; unsigned blue; unsigned opacity; red = *pixels++; green = *pixels++; blue = *pixels++; opacity = *pixels++; red = ((red * opacity) + (background.red * ((1 << 8) - opacity))); green = ((green * opacity) + (background.green * ((1 << 8) - opacity))); blue = ((blue * opacity) + (background.blue * ((1 << 8) - opacity))); XPutPixel (ximg, x, y, lookup_rgb_color (f, red, green, blue)); } pixels += rowstride - 4 * width; } #ifdef COLOR_TABLE_SUPPORT /* Remember colors allocated for this image. */ img->colors = colors_in_color_table (&img->ncolors); free_color_table (); #endif /* COLOR_TABLE_SUPPORT */ g_object_unref (pixbuf); /* Put the image into the pixmap, then free the X image and its buffer. */ x_put_x_image (f, ximg, img->pixmap, width, height); x_destroy_x_image (ximg); img->width = width; img->height = height; return 1; rsvg_error: /* FIXME: Use error->message. */ image_error ("Error parsing SVG image `%s'", img->spec, Qnil); g_error_free (error); return 0; } #endif /* defined (HAVE_RSVG) */ -- Joakim Verona