2 * Image Library -- GraphicsMagick (slow fallback library)
4 * (c) 2006 Pavel Charvat <pchar@ucw.cz>
6 * This software may be freely distributed and used according to the terms
7 * of the GNU Lesser General Public License.
13 #include "lib/mempool.h"
14 #include "lib/fastbuf.h"
15 #include "images/images.h"
16 #include <sys/types.h>
19 #include <magick/api.h>
21 #define MAX_FILE_SIZE (1 << 30)
22 #define QUANTUM_SCALE (QuantumDepth - 8)
23 #define QUANTUM_TO_BYTE(x) ((uns)(x) >> QUANTUM_SCALE)
24 #define BYTE_TO_QUANTUM(x) ((uns)(x) << QUANTUM_SCALE)
25 #define OPACITY_MAX ((1 << QuantumDepth) - 1)
27 struct magick_read_data {
28 ExceptionInfo exception;
34 libmagick_destroy_read_data(struct magick_read_data *rd)
37 DestroyImage(rd->image);
38 DestroyImageInfo(rd->info);
39 DestroyExceptionInfo(&rd->exception);
44 libmagick_read_cancel(struct image_io *io)
46 DBG("libmagick_read_cancel()");
48 struct magick_read_data *rd = io->read_data;
50 DestroyImage(rd->image);
51 libmagick_destroy_read_data(rd);
55 libmagick_read_header(struct image_io *io)
57 DBG("libmagick_read_header()");
59 /* Read entire stream */
60 sh_off_t file_size = bfilesize(io->fastbuf) - btell(io->fastbuf);
61 if (unlikely(file_size > MAX_FILE_SIZE))
63 image_thread_err(io->thread, IMAGE_ERR_READ_FAILED, "Too long stream.");
66 uns buf_size = file_size;
67 byte *buf = xmalloc(buf_size);
68 breadb(io->fastbuf, buf, buf_size);
70 /* Allocate read structure */
71 struct magick_read_data *rd = io->read_data = mp_alloc(io->internal_pool, sizeof(*rd));
73 /* Initialize GraphicsMagick */
74 InitializeMagick(NULL);
75 GetExceptionInfo(&rd->exception);
76 rd->info = CloneImageInfo(NULL);
77 rd->info->subrange = 1;
80 rd->image = BlobToImage(rd->info, buf, buf_size, &rd->exception);
82 if (unlikely(!rd->image))
84 image_thread_err(io->thread, IMAGE_ERR_READ_FAILED, "GraphicsMagick failed to read the image.");
87 if (unlikely(rd->image->columns > IMAGE_MAX_SIZE || rd->image->rows > IMAGE_MAX_SIZE))
89 image_thread_err(io->thread, IMAGE_ERR_INVALID_DIMENSIONS, "Image too large.");
93 /* Fill image parameters */
94 io->cols = rd->image->columns;
95 io->rows = rd->image->rows;
96 switch (rd->image->colorspace)
99 io->flags |= COLOR_SPACE_GRAYSCALE | IMAGE_ALPHA;
102 io->flags |= COLOR_SPACE_RGB | IMAGE_ALPHA;
105 io->number_of_colors = rd->image->colors;
106 if (rd->image->storage_class == PseudoClass && rd->image->compression != JPEGCompression)
109 io->read_cancel = libmagick_read_cancel;
113 libmagick_destroy_read_data(rd);
118 libmagick_pixel_to_gray(PixelPacket *pixel)
120 return ((uns)pixel->red * 19660 + (uns)pixel->green * 38666 + (uns)pixel->blue * 7210) >> (16 + QUANTUM_SCALE);
124 libmagick_read_data(struct image_io *io)
126 DBG("libmagick_read_data()");
128 struct magick_read_data *rd = io->read_data;
131 switch (rd->image->colorspace)
137 QuantizeInfo quantize;
138 GetQuantizeInfo(&quantize);
139 quantize.colorspace = RGBColorspace;
140 QuantizeImage(&quantize, rd->image);
144 /* Allocate image for conversion */
145 int need_scale = io->cols != rd->image->columns || io->rows != rd->image->rows;
146 int need_destroy = need_scale || !io->pool;
147 struct image *img = need_scale ?
148 image_new(io->thread, rd->image->columns, rd->image->rows, io->flags & IMAGE_CHANNELS_FORMAT, NULL) :
149 image_new(io->thread, io->cols, io->rows, io->flags, io->pool);
154 PixelPacket *src = (PixelPacket *)AcquireImagePixels(rd->image, 0, 0, rd->image->columns, rd->image->rows, &rd->exception);
157 image_thread_err(io->thread, IMAGE_ERR_READ_FAILED, "Cannot acquire image pixels.");
162 switch (img->pixel_size)
165 # define IMAGE_WALK_PREFIX(x) walk_##x
166 # define IMAGE_WALK_INLINE
167 # define IMAGE_WALK_IMAGE img
168 # define IMAGE_WALK_UNROLL 4
169 # define IMAGE_WALK_COL_STEP 1
170 # define IMAGE_WALK_DO_STEP do{ \
171 walk_pos[0] = libmagick_pixel_to_gray(src); \
173 # include "images/image-walk.h"
177 # define IMAGE_WALK_PREFIX(x) walk_##x
178 # define IMAGE_WALK_INLINE
179 # define IMAGE_WALK_IMAGE img
180 # define IMAGE_WALK_UNROLL 4
181 # define IMAGE_WALK_COL_STEP 2
182 # define IMAGE_WALK_DO_STEP do{ \
183 walk_pos[0] = libmagick_pixel_to_gray(src); \
184 walk_pos[1] = QUANTUM_TO_BYTE(src->opacity); \
186 # include "images/image-walk.h"
190 # define IMAGE_WALK_PREFIX(x) walk_##x
191 # define IMAGE_WALK_INLINE
192 # define IMAGE_WALK_IMAGE img
193 # define IMAGE_WALK_UNROLL 4
194 # define IMAGE_WALK_COL_STEP 3
195 # define IMAGE_WALK_DO_STEP do{ \
196 walk_pos[0] = QUANTUM_TO_BYTE(src->red); \
197 walk_pos[1] = QUANTUM_TO_BYTE(src->green); \
198 walk_pos[2] = QUANTUM_TO_BYTE(src->blue); \
200 # include "images/image-walk.h"
204 # define IMAGE_WALK_PREFIX(x) walk_##x
205 # define IMAGE_WALK_INLINE
206 # define IMAGE_WALK_IMAGE img
207 # define IMAGE_WALK_UNROLL 4
208 # define IMAGE_WALK_COL_STEP 4
209 # define IMAGE_WALK_DO_STEP do{ \
210 walk_pos[0] = QUANTUM_TO_BYTE(src->red); \
211 walk_pos[1] = QUANTUM_TO_BYTE(src->green); \
212 walk_pos[2] = QUANTUM_TO_BYTE(src->blue); \
213 walk_pos[3] = QUANTUM_TO_BYTE(src->opacity); \
215 # include "images/image-walk.h"
222 /* Free GraphicsMagick structures */
223 libmagick_destroy_read_data(rd);
228 struct image *img2 = image_new(io->thread, io->cols, io->rows, io->flags, io->pool);
231 int result = image_scale(io->thread, img2, img);
234 need_destroy = !io->pool;
235 if (unlikely(!result))
241 io->image_destroy = need_destroy;
244 /* Free structures */
246 libmagick_destroy_read_data(rd);
254 libmagick_write(struct image_io *io)
256 DBG("libmagick_write()");
258 /* Initialize GraphicsMagick */
260 ExceptionInfo exception;
262 InitializeMagick(NULL);
263 GetExceptionInfo(&exception);
264 info = CloneImageInfo(NULL);
266 /* Setup image parameters and allocate the image*/
267 struct image *img = io->image;
268 switch (img->flags & IMAGE_COLOR_SPACE)
270 case COLOR_SPACE_GRAYSCALE:
271 info->colorspace = GRAYColorspace;
273 case COLOR_SPACE_RGB:
274 info->colorspace = RGBColorspace;
281 case IMAGE_FORMAT_JPEG:
282 strcpy(info->magick, "JPEG");
283 if (io->jpeg_quality)
284 info->quality = MIN(io->jpeg_quality, 100);
286 case IMAGE_FORMAT_PNG:
287 strcpy(info->magick, "PNG");
289 case IMAGE_FORMAT_GIF:
290 strcpy(info->magick, "GIF");
295 Image *image = AllocateImage(info);
296 if (unlikely(!image))
298 image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "GraphicsMagick failed to allocate the image.");
301 image->columns = img->cols;
302 image->rows = img->rows;
305 PixelPacket *pixels = SetImagePixels(image, 0, 0, img->cols, img->rows), *dest = pixels;
306 if (unlikely(!pixels))
308 image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "Cannot get GraphicsMagick pixels.");
313 switch (img->pixel_size)
316 # define IMAGE_WALK_PREFIX(x) walk_##x
317 # define IMAGE_WALK_INLINE
318 # define IMAGE_WALK_IMAGE img
319 # define IMAGE_WALK_UNROLL 4
320 # define IMAGE_WALK_COL_STEP 1
321 # define IMAGE_WALK_DO_STEP do{ \
322 dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
323 dest->green = BYTE_TO_QUANTUM(walk_pos[0]); \
324 dest->blue = BYTE_TO_QUANTUM(walk_pos[0]); \
325 dest->opacity = OPACITY_MAX; \
327 # include "images/image-walk.h"
331 # define IMAGE_WALK_PREFIX(x) walk_##x
332 # define IMAGE_WALK_INLINE
333 # define IMAGE_WALK_IMAGE img
334 # define IMAGE_WALK_UNROLL 4
335 # define IMAGE_WALK_COL_STEP 2
336 # define IMAGE_WALK_DO_STEP do{ \
337 dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
338 dest->green = BYTE_TO_QUANTUM(walk_pos[0]); \
339 dest->blue = BYTE_TO_QUANTUM(walk_pos[0]); \
340 dest->opacity = BYTE_TO_QUANTUM(walk_pos[1]); \
342 # include "images/image-walk.h"
346 # define IMAGE_WALK_PREFIX(x) walk_##x
347 # define IMAGE_WALK_INLINE
348 # define IMAGE_WALK_IMAGE img
349 # define IMAGE_WALK_UNROLL 4
350 # define IMAGE_WALK_COL_STEP 3
351 # define IMAGE_WALK_DO_STEP do{ \
352 dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
353 dest->green = BYTE_TO_QUANTUM(walk_pos[1]); \
354 dest->blue = BYTE_TO_QUANTUM(walk_pos[2]); \
355 dest->opacity = OPACITY_MAX; \
357 # include "images/image-walk.h"
361 # define IMAGE_WALK_PREFIX(x) walk_##x
362 # define IMAGE_WALK_INLINE
363 # define IMAGE_WALK_IMAGE img
364 # define IMAGE_WALK_UNROLL 4
365 # define IMAGE_WALK_COL_STEP 4
366 # define IMAGE_WALK_DO_STEP do{ \
367 dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
368 dest->green = BYTE_TO_QUANTUM(walk_pos[1]); \
369 dest->blue = BYTE_TO_QUANTUM(walk_pos[2]); \
370 dest->opacity = BYTE_TO_QUANTUM(walk_pos[3]); \
372 # include "images/image-walk.h"
380 if (unlikely(!SyncImagePixels(image)))
382 image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "Cannot sync GraphicsMagick pixels.");
388 void *buf = ImageToBlob(info, image, &buf_len, &exception);
391 image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "GraphicsMagick failed to compress the image.");
394 if (unlikely(buf_len > MAX_FILE_SIZE))
396 image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "Image too large.");
400 /* Write to stream */
401 bwrite(io->fastbuf, buf, buf_len);
409 DestroyImageInfo(info);
410 DestroyExceptionInfo(&exception);