]> mj.ucw.cz Git - libucw.git/blob - images/io-libmagick.c
- bugfixes
[libucw.git] / images / io-libmagick.c
1 /*
2  *      Image Library -- GraphicsMagick (slow fallback library)
3  *
4  *      (c) 2006 Pavel Charvat <pchar@ucw.cz>
5  *
6  *      This software may be freely distributed and used according to the terms
7  *      of the GNU Lesser General Public License.
8  */
9
10 #undef LOCAL_DEBUG
11
12 #include "lib/lib.h"
13 #include "lib/mempool.h"
14 #include "lib/fastbuf.h"
15 #include "images/images.h"
16 #include "images/color.h"
17 #include "images/io-main.h"
18 #include <sys/types.h>
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <magick/api.h>
22
23 #define MAX_FILE_SIZE (1 << 30)
24 #define QUANTUM_SCALE (QuantumDepth - 8)
25 #define QUANTUM_TO_BYTE(x) ((uns)(x) >> QUANTUM_SCALE)
26 #define BYTE_TO_QUANTUM(x) ((uns)(x) << QUANTUM_SCALE)
27 #define OPACITY_MAX ((1 << QuantumDepth) - 1)
28
29 static uns libmagick_counter;
30
31 struct magick_read_data {
32   ExceptionInfo exception;
33   ImageInfo *info;
34   Image *image;
35 };
36
37 int
38 libmagick_init(struct image_io *io UNUSED)
39 {
40   // FIXME: lock
41   if (!libmagick_counter++)
42     InitializeMagick(NULL);
43   return 1;
44 }
45
46 void
47 libmagick_cleanup(struct image_io *io UNUSED)
48 {
49   // FIXME: lock
50   if (!--libmagick_counter)
51     DestroyMagick();
52 }
53
54 static void
55 libmagick_destroy_read_data(struct magick_read_data *rd)
56 {
57   if (rd->image)
58     DestroyImage(rd->image);
59   DestroyImageInfo(rd->info);
60   DestroyExceptionInfo(&rd->exception);
61 }
62
63 static void
64 libmagick_read_cancel(struct image_io *io)
65 {
66   DBG("libmagick_read_cancel()");
67
68   struct magick_read_data *rd = io->read_data;
69   libmagick_destroy_read_data(rd);
70 }
71
72 int
73 libmagick_read_header(struct image_io *io)
74 {
75   DBG("libmagick_read_header()");
76
77   /* Read entire stream */
78   sh_off_t file_size = bfilesize(io->fastbuf) - btell(io->fastbuf);
79   if (unlikely(file_size > MAX_FILE_SIZE))
80     {
81       image_thread_err(io->thread, IMAGE_ERR_READ_FAILED, "Too long stream.");
82       return 0;
83     }
84   uns buf_size = file_size;
85   byte *buf = xmalloc(buf_size);
86   breadb(io->fastbuf, buf, buf_size);
87
88   /* Allocate read structure */
89   struct magick_read_data *rd = io->read_data = mp_alloc_zero(io->internal_pool, sizeof(*rd));
90
91   /* Initialize GraphicsMagick */
92   GetExceptionInfo(&rd->exception);
93   rd->info = CloneImageInfo(NULL);
94   rd->info->subrange = 1;
95
96   /* Read the image */
97   rd->image = BlobToImage(rd->info, buf, buf_size, &rd->exception);
98   xfree(buf);
99   if (unlikely(!rd->image))
100     {
101       image_thread_err(io->thread, IMAGE_ERR_READ_FAILED, "GraphicsMagick failed to read the image.");
102       goto err;
103     }
104   if (unlikely(rd->image->columns > IMAGE_MAX_SIZE || rd->image->rows > IMAGE_MAX_SIZE))
105     {
106       image_thread_err(io->thread, IMAGE_ERR_INVALID_DIMENSIONS, "Image too large.");
107       goto err;
108     }
109
110   /* Fill image parameters */
111   io->cols = rd->image->columns;
112   io->rows = rd->image->rows;
113   switch (rd->image->colorspace)
114     {
115       case GRAYColorspace:
116         io->flags = COLOR_SPACE_GRAYSCALE;
117         break;
118       default:
119         io->flags = COLOR_SPACE_RGB;
120         break;
121     }
122   if (rd->image->matte)
123     io->flags |= IMAGE_ALPHA;
124   io->number_of_colors = rd->image->colors;
125   if (rd->image->storage_class == PseudoClass && rd->image->compression != JPEGCompression)
126     io->flags |= IMAGE_IO_HAS_PALETTE;
127
128   io->read_cancel = libmagick_read_cancel;
129   return 1;
130
131 err:
132   libmagick_destroy_read_data(rd);
133   return 0;
134 }
135
136 static inline byte
137 libmagick_pixel_to_gray(PixelPacket *pixel)
138 {
139   return rgb_to_gray_func(pixel->red, pixel->green, pixel->blue) >> QUANTUM_SCALE;
140 }
141
142 int
143 libmagick_read_data(struct image_io *io)
144 {
145   DBG("libmagick_read_data()");
146
147   struct magick_read_data *rd = io->read_data;
148
149   /* Quantize image */
150   switch (rd->image->colorspace)
151     {
152       case RGBColorspace:
153       case GRAYColorspace:
154         break;
155       default: ;
156         QuantizeInfo quantize;
157         GetQuantizeInfo(&quantize);
158         quantize.colorspace = RGBColorspace;
159         QuantizeImage(&quantize, rd->image);
160         break;
161     }
162
163   /* Prepare the image */
164   struct image_io_read_data_internals rdi;
165   uns read_flags = io->flags;
166   if ((read_flags & IMAGE_IO_USE_BACKGROUND) && !(read_flags & IMAGE_ALPHA))
167     read_flags = (read_flags | IMAGE_ALPHA) & IMAGE_CHANNELS_FORMAT;
168   if (unlikely(!image_io_read_data_prepare(&rdi, io, rd->image->columns, rd->image->rows, read_flags)))
169     {
170       libmagick_destroy_read_data(rd);
171       return 0;
172     }
173
174   /* Acquire pixels */
175   PixelPacket *src = (PixelPacket *)AcquireImagePixels(rd->image, 0, 0, rd->image->columns, rd->image->rows, &rd->exception);
176   if (unlikely(!src))
177     {
178       image_thread_err(io->thread, IMAGE_ERR_READ_FAILED, "Cannot acquire image pixels.");
179       libmagick_destroy_read_data(rd);
180       image_io_read_data_break(&rdi, io);
181       return 0;
182     }
183
184   /* Convert pixels */
185   switch (rdi.image->pixel_size)
186     {
187       case 1:
188 #       define IMAGE_WALK_PREFIX(x) walk_##x
189 #       define IMAGE_WALK_INLINE
190 #       define IMAGE_WALK_IMAGE (rdi.image)
191 #       define IMAGE_WALK_UNROLL 4
192 #       define IMAGE_WALK_COL_STEP 1
193 #       define IMAGE_WALK_DO_STEP do{ \
194           walk_pos[0] = libmagick_pixel_to_gray(src); \
195           src++; }while(0)
196 #       include "images/image-walk.h"
197         break;
198
199       case 2:
200 #       define IMAGE_WALK_PREFIX(x) walk_##x
201 #       define IMAGE_WALK_INLINE
202 #       define IMAGE_WALK_IMAGE (rdi.image)
203 #       define IMAGE_WALK_UNROLL 4
204 #       define IMAGE_WALK_COL_STEP 2
205 #       define IMAGE_WALK_DO_STEP do{ \
206           walk_pos[0] = libmagick_pixel_to_gray(src); \
207           walk_pos[1] = QUANTUM_TO_BYTE(src->opacity); \
208           src++; }while(0)
209 #       include "images/image-walk.h"
210         break;
211
212       case 3:
213 #       define IMAGE_WALK_PREFIX(x) walk_##x
214 #       define IMAGE_WALK_INLINE
215 #       define IMAGE_WALK_IMAGE (rdi.image)
216 #       define IMAGE_WALK_UNROLL 4
217 #       define IMAGE_WALK_COL_STEP 3
218 #       define IMAGE_WALK_DO_STEP do{ \
219           walk_pos[0] = QUANTUM_TO_BYTE(src->red); \
220           walk_pos[1] = QUANTUM_TO_BYTE(src->green); \
221           walk_pos[2] = QUANTUM_TO_BYTE(src->blue); \
222           src++; }while(0)
223 #       include "images/image-walk.h"
224         break;
225
226       case 4:
227 #       define IMAGE_WALK_PREFIX(x) walk_##x
228 #       define IMAGE_WALK_INLINE
229 #       define IMAGE_WALK_IMAGE (rdi.image)
230 #       define IMAGE_WALK_UNROLL 4
231 #       define IMAGE_WALK_COL_STEP 4
232 #       define IMAGE_WALK_DO_STEP do{ \
233           walk_pos[0] = QUANTUM_TO_BYTE(src->red); \
234           walk_pos[1] = QUANTUM_TO_BYTE(src->green); \
235           walk_pos[2] = QUANTUM_TO_BYTE(src->blue); \
236           walk_pos[3] = QUANTUM_TO_BYTE(src->opacity); \
237           src++; }while(0)
238 #       include "images/image-walk.h"
239         break;
240
241       default:
242         ASSERT(0);
243     }
244
245   /* Free GraphicsMagick structures */
246   libmagick_destroy_read_data(rd);
247
248   /* Finish the image */
249   return image_io_read_data_finish(&rdi, io);
250 }
251
252 int
253 libmagick_write(struct image_io *io)
254 {
255   DBG("libmagick_write()");
256
257   /* Initialize GraphicsMagick */
258   int result = 0;
259   ExceptionInfo exception;
260   ImageInfo *info;
261   GetExceptionInfo(&exception);
262   info = CloneImageInfo(NULL);
263
264   /* Setup image parameters and allocate the image*/
265   struct image *img = io->image;
266   switch (img->flags & IMAGE_COLOR_SPACE)
267     {
268       case COLOR_SPACE_GRAYSCALE:
269         info->colorspace = GRAYColorspace;
270         break;
271       case COLOR_SPACE_RGB:
272         info->colorspace = RGBColorspace;
273         break;
274       default:
275         ASSERT(0);
276     }
277   switch (io->format)
278     {
279       case IMAGE_FORMAT_JPEG:
280         strcpy(info->magick, "JPEG");
281         if (io->jpeg_quality)
282           info->quality = MIN(io->jpeg_quality, 100);
283         break;
284       case IMAGE_FORMAT_PNG:
285         strcpy(info->magick, "PNG");
286         break;
287       case IMAGE_FORMAT_GIF:
288         strcpy(info->magick, "GIF");
289         break;
290       default:
291         ASSERT(0);
292     }
293   Image *image = AllocateImage(info);
294   if (unlikely(!image))
295     {
296       image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "GraphicsMagick failed to allocate the image.");
297       goto err;
298     }
299   image->columns = img->cols;
300   image->rows = img->rows;
301
302   /* Get pixels */
303   PixelPacket *pixels = SetImagePixels(image, 0, 0, img->cols, img->rows), *dest = pixels;
304   if (unlikely(!pixels))
305     {
306       image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "Cannot get GraphicsMagick pixels.");
307       goto err2;
308     }
309
310   /* Convert pixels */
311   switch (img->pixel_size)
312     {
313       case 1:
314 #       define IMAGE_WALK_PREFIX(x) walk_##x
315 #       define IMAGE_WALK_INLINE
316 #       define IMAGE_WALK_IMAGE img
317 #       define IMAGE_WALK_UNROLL 4
318 #       define IMAGE_WALK_COL_STEP 1
319 #       define IMAGE_WALK_DO_STEP do{ \
320           dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
321           dest->green = BYTE_TO_QUANTUM(walk_pos[0]); \
322           dest->blue = BYTE_TO_QUANTUM(walk_pos[0]); \
323           dest->opacity = OPACITY_MAX; \
324           dest++; }while(0)
325 #       include "images/image-walk.h"
326         break;
327
328       case 2:
329 #       define IMAGE_WALK_PREFIX(x) walk_##x
330 #       define IMAGE_WALK_INLINE
331 #       define IMAGE_WALK_IMAGE img
332 #       define IMAGE_WALK_UNROLL 4
333 #       define IMAGE_WALK_COL_STEP 2
334 #       define IMAGE_WALK_DO_STEP do{ \
335           dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
336           dest->green = BYTE_TO_QUANTUM(walk_pos[0]); \
337           dest->blue = BYTE_TO_QUANTUM(walk_pos[0]); \
338           dest->opacity = BYTE_TO_QUANTUM(walk_pos[1]); \
339           dest++; }while(0)
340 #       include "images/image-walk.h"
341         break;
342
343       case 3:
344 #       define IMAGE_WALK_PREFIX(x) walk_##x
345 #       define IMAGE_WALK_INLINE
346 #       define IMAGE_WALK_IMAGE img
347 #       define IMAGE_WALK_UNROLL 4
348 #       define IMAGE_WALK_COL_STEP 3
349 #       define IMAGE_WALK_DO_STEP do{ \
350           dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
351           dest->green = BYTE_TO_QUANTUM(walk_pos[1]); \
352           dest->blue = BYTE_TO_QUANTUM(walk_pos[2]); \
353           dest->opacity = OPACITY_MAX; \
354           dest++; }while(0)
355 #       include "images/image-walk.h"
356         break;
357
358       case 4:
359 #       define IMAGE_WALK_PREFIX(x) walk_##x
360 #       define IMAGE_WALK_INLINE
361 #       define IMAGE_WALK_IMAGE img
362 #       define IMAGE_WALK_UNROLL 4
363 #       define IMAGE_WALK_COL_STEP 4
364 #       define IMAGE_WALK_DO_STEP do{ \
365           dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
366           dest->green = BYTE_TO_QUANTUM(walk_pos[1]); \
367           dest->blue = BYTE_TO_QUANTUM(walk_pos[2]); \
368           dest->opacity = BYTE_TO_QUANTUM(walk_pos[3]); \
369           dest++; }while(0)
370 #       include "images/image-walk.h"
371         break;
372
373       default:
374         ASSERT(0);
375     }
376
377   /* Store pixels */
378   if (unlikely(!SyncImagePixels(image)))
379     {
380       image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "Cannot sync GraphicsMagick pixels.");
381       goto err2;
382     }
383
384   /* Write image */
385   size_t buf_len = 0;
386   void *buf = ImageToBlob(info, image, &buf_len, &exception);
387   if (unlikely(!buf))
388     {
389       image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "GraphicsMagick failed to compress the image.");
390       goto err2;
391     }
392   if (unlikely(buf_len > MAX_FILE_SIZE))
393     {
394       image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "Image too large.");
395       goto err2;
396     }
397
398   /* Write to stream */
399   bwrite(io->fastbuf, buf, buf_len);
400
401   /* Success */
402   result = 1;
403
404 err2:
405   DestroyImage(image);
406 err:
407   DestroyImageInfo(info);
408   DestroyExceptionInfo(&exception);
409   return result;
410 }