* of the GNU Lesser General Public License.
*/
-#define LOCAL_DEBUG
+#undef LOCAL_DEBUG
#include "lib/lib.h"
#include "lib/mempool.h"
#include "lib/fastbuf.h"
#include "images/images.h"
+#include "images/color.h"
+#include "images/io-main.h"
#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#define QUANTUM_SCALE (QuantumDepth - 8)
#define QUANTUM_TO_BYTE(x) ((uns)(x) >> QUANTUM_SCALE)
#define BYTE_TO_QUANTUM(x) ((uns)(x) << QUANTUM_SCALE)
-#define OPACITY_MAX ((1 << QuantumDepth) - 1)
+#define ALPHA_TO_BYTE(x) (255 - QUANTUM_TO_BYTE(x))
+#define BYTE_TO_ALPHA(x) (BYTE_TO_QUANTUM(255 - (x)))
+
+static uns libmagick_counter;
struct magick_read_data {
ExceptionInfo exception;
Image *image;
};
-static inline void
+int
+libmagick_init(struct image_io *io UNUSED)
+{
+ // FIXME: lock
+ if (!libmagick_counter++)
+ InitializeMagick(NULL);
+ return 1;
+}
+
+void
+libmagick_cleanup(struct image_io *io UNUSED)
+{
+ // FIXME: lock
+ if (!--libmagick_counter)
+ DestroyMagick();
+}
+
+static void
libmagick_destroy_read_data(struct magick_read_data *rd)
{
if (rd->image)
DestroyImage(rd->image);
DestroyImageInfo(rd->info);
DestroyExceptionInfo(&rd->exception);
- DestroyMagick();
}
static void
DBG("libmagick_read_cancel()");
struct magick_read_data *rd = io->read_data;
-
- DestroyImage(rd->image);
libmagick_destroy_read_data(rd);
}
}
uns buf_size = file_size;
byte *buf = xmalloc(buf_size);
- bread(io->fastbuf, buf, buf_size);
+ breadb(io->fastbuf, buf, buf_size);
/* Allocate read structure */
- struct magick_read_data *rd = io->read_data = mp_alloc(io->internal_pool, sizeof(*rd));
+ struct magick_read_data *rd = io->read_data = mp_alloc_zero(io->internal_pool, sizeof(*rd));
/* Initialize GraphicsMagick */
- InitializeMagick(NULL);
GetExceptionInfo(&rd->exception);
rd->info = CloneImageInfo(NULL);
rd->info->subrange = 1;
}
/* Fill image parameters */
- if (!io->cols)
- io->cols = rd->image->columns;
- if (!io->rows)
- io->rows = rd->image->rows;
- if (!(io->flags & IMAGE_CHANNELS_FORMAT))
+ io->cols = rd->image->columns;
+ io->rows = rd->image->rows;
+ switch (rd->image->colorspace)
{
- switch (rd->image->colorspace)
- {
- case GRAYColorspace:
- io->flags |= COLOR_SPACE_GRAYSCALE | IMAGE_ALPHA;
- break;
- default:
- io->flags |= COLOR_SPACE_RGB | IMAGE_ALPHA;
- break;
- }
+ case GRAYColorspace:
+ io->flags = COLOR_SPACE_GRAYSCALE;
+ break;
+ default:
+ io->flags = COLOR_SPACE_RGB;
+ break;
}
+ if (rd->image->matte)
+ io->flags |= IMAGE_ALPHA;
+ io->number_of_colors = rd->image->colors;
+ if (rd->image->storage_class == PseudoClass && rd->image->compression != JPEGCompression)
+ io->flags |= IMAGE_IO_HAS_PALETTE;
io->read_cancel = libmagick_read_cancel;
return 1;
static inline byte
libmagick_pixel_to_gray(PixelPacket *pixel)
{
- return ((uns)pixel->red * 19660 + (uns)pixel->green * 38666 + (uns)pixel->blue * 7210) >> (16 + QUANTUM_SCALE);
+ return rgb_to_gray_func(pixel->red, pixel->green, pixel->blue) >> QUANTUM_SCALE;
}
int
break;
}
- /* Allocate image for conversion */
- int need_scale = io->cols != rd->image->columns || io->rows != rd->image->rows;
- int need_destroy = need_scale || !io->pool;
- struct image *img = need_scale ?
- image_new(io->thread, rd->image->columns, rd->image->rows, io->flags & IMAGE_CHANNELS_FORMAT, NULL) :
- image_new(io->thread, io->cols, io->rows, io->flags, io->pool);
- if (unlikely(!img))
- goto err;
+ /* Prepare the image */
+ struct image_io_read_data_internals rdi;
+ uns read_flags = io->flags;
+ if ((read_flags & IMAGE_IO_USE_BACKGROUND) && !(read_flags & IMAGE_ALPHA))
+ read_flags = (read_flags | IMAGE_ALPHA) & IMAGE_CHANNELS_FORMAT;
+ if (unlikely(!image_io_read_data_prepare(&rdi, io, rd->image->columns, rd->image->rows, read_flags)))
+ {
+ libmagick_destroy_read_data(rd);
+ return 0;
+ }
/* Acquire pixels */
PixelPacket *src = (PixelPacket *)AcquireImagePixels(rd->image, 0, 0, rd->image->columns, rd->image->rows, &rd->exception);
if (unlikely(!src))
{
image_thread_err(io->thread, IMAGE_ERR_READ_FAILED, "Cannot acquire image pixels.");
- goto err;
+ libmagick_destroy_read_data(rd);
+ image_io_read_data_break(&rdi, io);
+ return 0;
}
/* Convert pixels */
- switch (img->pixel_size)
+ switch (rdi.image->pixel_size)
{
case 1:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE (rdi.image)
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 1
# define IMAGE_WALK_DO_STEP do{ \
- pos[0] = libmagick_pixel_to_gray(src); \
+ walk_pos[0] = libmagick_pixel_to_gray(src); \
src++; }while(0)
# include "images/image-walk.h"
break;
case 2:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE (rdi.image)
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 2
# define IMAGE_WALK_DO_STEP do{ \
- pos[0] = libmagick_pixel_to_gray(src); \
- pos[1] = QUANTUM_TO_BYTE(src->opacity); \
+ walk_pos[0] = libmagick_pixel_to_gray(src); \
+ walk_pos[1] = ALPHA_TO_BYTE(src->opacity); \
src++; }while(0)
# include "images/image-walk.h"
break;
case 3:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE (rdi.image)
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 3
# define IMAGE_WALK_DO_STEP do{ \
- pos[0] = QUANTUM_TO_BYTE(src->red); \
- pos[1] = QUANTUM_TO_BYTE(src->green); \
- pos[2] = QUANTUM_TO_BYTE(src->blue); \
+ walk_pos[0] = QUANTUM_TO_BYTE(src->red); \
+ walk_pos[1] = QUANTUM_TO_BYTE(src->green); \
+ walk_pos[2] = QUANTUM_TO_BYTE(src->blue); \
src++; }while(0)
# include "images/image-walk.h"
break;
case 4:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE (rdi.image)
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 4
# define IMAGE_WALK_DO_STEP do{ \
- pos[0] = QUANTUM_TO_BYTE(src->red); \
- pos[1] = QUANTUM_TO_BYTE(src->green); \
- pos[2] = QUANTUM_TO_BYTE(src->blue); \
- pos[3] = QUANTUM_TO_BYTE(src->opacity); \
+ walk_pos[0] = QUANTUM_TO_BYTE(src->red); \
+ walk_pos[1] = QUANTUM_TO_BYTE(src->green); \
+ walk_pos[2] = QUANTUM_TO_BYTE(src->blue); \
+ walk_pos[3] = ALPHA_TO_BYTE(src->opacity); \
src++; }while(0)
# include "images/image-walk.h"
break;
/* Free GraphicsMagick structures */
libmagick_destroy_read_data(rd);
- /* Scale image */
- if (need_scale)
- {
- struct image *img2 = image_new(io->thread, io->cols, io->rows, io->flags, io->pool);
- if (unlikely(!img2))
- goto err2;
- int result = image_scale(io->thread, img2, img);
- image_destroy(io->thread, img);
- img = img2;
- need_destroy = !io->pool;
- if (unlikely(!result))
- goto err2;
- }
-
- /* Success */
- io->image = img;
- io->image_destroy = need_destroy;
- return 1;
-
- /* Free structures */
-err:
- libmagick_destroy_read_data(rd);
-err2:
- if (need_destroy)
- image_destroy(io->thread, img);
- return 0;
+ /* Finish the image */
+ return image_io_read_data_finish(&rdi, io);
}
int
int result = 0;
ExceptionInfo exception;
ImageInfo *info;
- InitializeMagick(NULL);
GetExceptionInfo(&exception);
info = CloneImageInfo(NULL);
/* Setup image parameters and allocate the image*/
- switch (io->flags & IMAGE_COLOR_SPACE)
+ struct image *img = io->image;
+ switch (img->flags & IMAGE_COLOR_SPACE)
{
case COLOR_SPACE_GRAYSCALE:
info->colorspace = GRAYColorspace;
{
case IMAGE_FORMAT_JPEG:
strcpy(info->magick, "JPEG");
+ if (io->jpeg_quality)
+ info->quality = MIN(io->jpeg_quality, 100);
break;
case IMAGE_FORMAT_PNG:
strcpy(info->magick, "PNG");
image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "GraphicsMagick failed to allocate the image.");
goto err;
}
- image->columns = io->cols;
- image->rows = io->rows;
+ image->columns = img->cols;
+ image->rows = img->rows;
/* Get pixels */
- PixelPacket *pixels = SetImagePixels(image, 0, 0, io->cols, io->rows), *dest = pixels;
+ PixelPacket *pixels = SetImagePixels(image, 0, 0, img->cols, img->rows), *dest = pixels;
if (unlikely(!pixels))
{
image_thread_err(io->thread, IMAGE_ERR_WRITE_FAILED, "Cannot get GraphicsMagick pixels.");
}
/* Convert pixels */
- struct image *img = io->image;
switch (img->pixel_size)
{
case 1:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE img
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 1
# define IMAGE_WALK_DO_STEP do{ \
- dest->red = BYTE_TO_QUANTUM(pos[0]); \
- dest->green = BYTE_TO_QUANTUM(pos[0]); \
- dest->blue = BYTE_TO_QUANTUM(pos[0]); \
- dest->opacity = OPACITY_MAX; \
+ dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->green = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->blue = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->opacity = 0; \
dest++; }while(0)
# include "images/image-walk.h"
break;
+
case 2:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE img
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 2
# define IMAGE_WALK_DO_STEP do{ \
- dest->red = BYTE_TO_QUANTUM(pos[0]); \
- dest->green = BYTE_TO_QUANTUM(pos[0]); \
- dest->blue = BYTE_TO_QUANTUM(pos[0]); \
- dest->opacity = BYTE_TO_QUANTUM(pos[1]); \
+ dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->green = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->blue = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->opacity = BYTE_TO_ALPHA(walk_pos[1]); \
dest++; }while(0)
# include "images/image-walk.h"
break;
+
case 3:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE img
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 3
# define IMAGE_WALK_DO_STEP do{ \
- dest->red = BYTE_TO_QUANTUM(pos[0]); \
- dest->green = BYTE_TO_QUANTUM(pos[1]); \
- dest->blue = BYTE_TO_QUANTUM(pos[2]); \
- dest->opacity = OPACITY_MAX; \
+ dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->green = BYTE_TO_QUANTUM(walk_pos[1]); \
+ dest->blue = BYTE_TO_QUANTUM(walk_pos[2]); \
+ dest->opacity = 0; \
dest++; }while(0)
# include "images/image-walk.h"
break;
+
case 4:
+# define IMAGE_WALK_PREFIX(x) walk_##x
# define IMAGE_WALK_INLINE
+# define IMAGE_WALK_IMAGE img
# define IMAGE_WALK_UNROLL 4
# define IMAGE_WALK_COL_STEP 4
# define IMAGE_WALK_DO_STEP do{ \
- dest->red = BYTE_TO_QUANTUM(pos[0]); \
- dest->green = BYTE_TO_QUANTUM(pos[1]); \
- dest->blue = BYTE_TO_QUANTUM(pos[2]); \
- dest->opacity = BYTE_TO_QUANTUM(pos[3]); \
+ dest->red = BYTE_TO_QUANTUM(walk_pos[0]); \
+ dest->green = BYTE_TO_QUANTUM(walk_pos[1]); \
+ dest->blue = BYTE_TO_QUANTUM(walk_pos[2]); \
+ dest->opacity = BYTE_TO_ALPHA(walk_pos[3]); \
dest++; }while(0)
# include "images/image-walk.h"
break;
+
+ default:
+ ASSERT(0);
}
/* Store pixels */
err:
DestroyImageInfo(info);
DestroyExceptionInfo(&exception);
- DestroyMagick();
return result;
}