diff --git a/CMakeLists.txt b/CMakeLists.txt index 8b07470..764d5f6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,6 +38,7 @@ if(WIN32) else(WIN32) set(ENABLE_RELOCATABLE OFF) endif(WIN32) +option(ENABLE_IMAGEMAGICK "Use ImageMagick for image scaling in the Splash backend." OFF) set(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)") @@ -157,6 +158,11 @@ if(ENABLE_LIBCURL) include_directories(${CURL_INCLUDE_DIR}) set(POPPLER_HAS_CURL_SUPPORT ON) endif(ENABLE_LIBCURL) +if(ENABLE_IMAGEMAGICK) + find_package(ImageMagick COMPONENTS Magick++) + include_directories(${ImageMagick_INCLUDE_DIRS}) + set(ImageMagick_CFLAGS "-I${ImageMagick_INCLUDE_DIRS}") +endif(ENABLE_IMAGEMAGICK) add_definitions(-DHAVE_CONFIG_H=1) if(FONTCONFIG_FOUND) @@ -241,6 +247,7 @@ set(poppler_SRCS goo/PNGWriter.cc goo/TiffWriter.cc goo/JpegWriter.cc + goo/MagickWriter.cc goo/ImgWriter.cc goo/gstrtod.cc fofi/FoFiBase.cc @@ -381,6 +388,9 @@ endif(WIN32) if(PNG_FOUND) set(poppler_LIBS ${poppler_LIBS} ${PNG_LIBRARIES}) endif(PNG_FOUND) +if(ENABLE_IMAGEMAGICK) + set(poppler_LIBS ${poppler_LIBS} ${ImageMagick_LIBRARIES}) +endif(ENABLE_IMAGEMAGICK) if(TIFF_FOUND) set(poppler_LIBS ${poppler_LIBS} ${TIFF_LIBRARIES}) endif(TIFF_FOUND) @@ -495,6 +505,11 @@ if(ENABLE_XPDF_HEADERS) goo/TiffWriter.h DESTINATION include/poppler/goo) endif(TIFF_FOUND) + if(IMAGEMAGICK_FOUND) + install(FILES + goo/MagickWriter.h + DESTINATION include/poppler/goo) + endif(IMAGEMAGICK_FOUND) install(FILES fofi/FoFiBase.h fofi/FoFiEncodings.h @@ -610,6 +625,7 @@ show_end_message_yesno("cpp wrapper" ENABLE_CPP) show_end_message("use gtk-doc" "not supported with this CMake build system") show_end_message_yesno("use libjpeg" ENABLE_LIBJPEG) show_end_message_yesno("use libpng" ENABLE_LIBPNG) +show_end_message_yesno("use imagemagick" ENABLE_IMAGEMAGICK) show_end_message_yesno("use libtiff" ENABLE_LIBTIFF) show_end_message_yesno("use zlib" ENABLE_ZLIB) show_end_message_yesno("use curl" ENABLE_LIBCURL) diff --git a/config.h.cmake b/config.h.cmake index 3c7b968..396bffa 100644 --- a/config.h.cmake +++ b/config.h.cmake @@ -15,6 +15,9 @@ /* Build against libpng. */ #cmakedefine ENABLE_LIBPNG 1 +/* Build against imagemagick. */ +#cmakedefine ENABLE_IMAGEMAGICK 1 + /* Do not hardcode the library location */ #cmakedefine ENABLE_RELOCATABLE 1 diff --git a/configure.ac b/configure.ac index 62a27b9..4645b3d 100644 --- a/configure.ac +++ b/configure.ac @@ -395,6 +395,24 @@ fi AM_CONDITIONAL(BUILD_LIBPNG, test x$enable_libpng = xyes) +dnl Test for ImageMagick Magick++ +AC_ARG_ENABLE(imagemagick, + AC_HELP_STRING([--enable-imagemagick], + [Use ImageMagick for image scaling in the Splash backend.]), + enable_imagemagick=$enableval, + enable_imagemagick="no") + +if test x$enable_imagemagick != xno; then + PKG_CHECK_MODULES(IMAGEMAGICK, ImageMagick++, [enable_imagemagick="yes"], + [enable_imagemagick="no"]) +fi + +if test x$enable_imagemagick = xyes; then + AC_DEFINE(ENABLE_IMAGEMAGICK, 1, [Build against ImageMagick.]) +fi + +AM_CONDITIONAL(BUILD_IMAGEMAGICK, test x$enable_imagemagick = xyes) + dnl Check for freetype headers PKG_CHECK_MODULES(FREETYPE, freetype2, @@ -819,6 +837,7 @@ echo " use zlib: $enable_zlib" echo " use libcurl: $enable_libcurl" echo " use libopenjpeg: $enable_libopenjpeg" echo " use cms: $enable_cms" +echo " use imagemagick: $enable_imagemagick" if test x$enable_cms = xyes;then if test x$lcms1 = xyes;then echo " with lcms1" diff --git a/goo/MagickWriter.cc b/goo/MagickWriter.cc new file mode 100644 index 0000000..7b32ca0 --- /dev/null +++ b/goo/MagickWriter.cc @@ -0,0 +1,74 @@ +//======================================================================== +// +// MagickWriter.h +// +// This file is licensed under the GPLv2 or later +// +// Copyright (C) 2012 Stefan Talpalaru +// +//======================================================================== + +#include "MagickWriter.h" + +#ifdef ENABLE_IMAGEMAGICK + +MagickWriter::MagickWriter() +{ + image = NULL; + cur_row = 0; +} + +MagickWriter::~MagickWriter() +{ +} + +bool MagickWriter::init(FILE *f, int width, int height, int hDPI, int vDPI) +{ + using namespace Magick; + img_width = width; + img_height = height; + image = new Image(Geometry(width, height), Color(0, 0, 0)); + image->modifyImage(); + pixel_cache = image->getPixels(0, 0, width, height); + return true; +} + +bool MagickWriter::writePointers(unsigned char **rowPointers, int rowCount) +{ + int row; + + if (rowCount == img_height) { + image->read(img_width, img_height, "RGB", Magick::CharPixel, *rowPointers); + } else { + for (row = 0; row < rowCount; row++) { + writeRow(&rowPointers[row]); + } + } + return true; +} + +bool MagickWriter::writeRow(unsigned char **row) +{ + using namespace Magick; + int x; + + pixel = pixel_cache + img_width * cur_row; + for (x = 0; x < img_width; x++) { + pixel->red = (*row)[3 * x] * MaxRGB / 255; + pixel->green = (*row)[3 * x + 1] * MaxRGB / 255; + pixel->blue = (*row)[3 * x + 2] * MaxRGB / 255; + pixel++; + } + + cur_row++; + return true; +} + +bool MagickWriter::close() +{ + image->syncPixels(); + return true; +} + +#endif + diff --git a/goo/MagickWriter.h b/goo/MagickWriter.h new file mode 100644 index 0000000..5f05cf7 --- /dev/null +++ b/goo/MagickWriter.h @@ -0,0 +1,44 @@ +//======================================================================== +// +// MagickWriter.h +// +// This file is licensed under the GPLv2 or later +// +// Copyright (C) 2012 Stefan Talpalaru +// +//======================================================================== + +#ifndef MAGICKWRITER_H +#define MAGICKWRITER_H + +#include "poppler-config.h" + +#ifdef ENABLE_IMAGEMAGICK +#include +#include "ImgWriter.h" + +class MagickWriter : public ImgWriter +{ + public: + MagickWriter(); + ~MagickWriter(); + bool init(FILE *f, int width, int height, int hDPI, int vDPI); + bool writePointers(unsigned char **rowPointers, int rowCount); + bool writeRow(unsigned char **row); + bool close(); + + private: + Magick::Image *image; + int img_width; + int img_height; + int cur_row; + Magick::PixelPacket *pixel_cache, *pixel; + + friend class Splash; +}; + + + +#endif + +#endif diff --git a/goo/Makefile.am b/goo/Makefile.am index f4f9730..25005ff 100644 --- a/goo/Makefile.am +++ b/goo/Makefile.am @@ -16,6 +16,7 @@ poppler_goo_include_HEADERS = \ PNGWriter.h \ JpegWriter.h \ TiffWriter.h \ + MagickWriter.h \ ImgWriter.h \ GooLikely.h \ gstrtod.h @@ -38,11 +39,16 @@ if BUILD_LIBPNG libpng_includes = $(LIBPNG_CFLAGS) endif +if BUILD_IMAGEMAGICK +imagemagick_includes = $(IMAGEMAGICK_CFLAGS) +endif + INCLUDES = \ -I$(top_srcdir) \ $(libjpeg_includes) \ $(libtiff_includes) \ $(libjpeg2000_includes) \ + $(imagemagick_includes) \ $(libpng_includes) libgoo_la_SOURCES = \ @@ -57,6 +63,7 @@ libgoo_la_SOURCES = \ PNGWriter.cc \ JpegWriter.cc \ TiffWriter.cc \ + MagickWriter.cc \ ImgWriter.cc \ gtypes_p.h \ gstrtod.cc diff --git a/poppler.pc.cmake b/poppler.pc.cmake index f1aebed..cf59ba8 100644 --- a/poppler.pc.cmake +++ b/poppler.pc.cmake @@ -8,4 +8,4 @@ Description: PDF rendering library Version: @POPPLER_VERSION@ Libs: -L${libdir} -lpoppler -Cflags: -I${includedir}/poppler +Cflags: -I${includedir}/poppler @ImageMagick_CFLAGS@ diff --git a/poppler.pc.in b/poppler.pc.in index 8605b28..ec25516 100644 --- a/poppler.pc.in +++ b/poppler.pc.in @@ -8,4 +8,4 @@ Description: PDF rendering library Version: @VERSION@ Libs: -L${libdir} -lpoppler -Cflags: -I${includedir}/poppler +Cflags: -I${includedir}/poppler @IMAGEMAGICK_CFLAGS@ diff --git a/poppler/Makefile.am b/poppler/Makefile.am index 8920f8e..cb01cc7 100644 --- a/poppler/Makefile.am +++ b/poppler/Makefile.am @@ -138,6 +138,15 @@ cms_includes = $(LCMS_CFLAGS) cms_libs = $(LCMS_LIBS) endif +if BUILD_IMAGEMAGICK + +imagemagick_libs = \ + $(IMAGEMAGICK_LIBS) +imagemagick_includes = \ + $(IMAGEMAGICK_CFLAGS) + +endif + INCLUDES = \ -I$(top_srcdir) \ -I$(top_srcdir)/goo \ @@ -150,6 +159,7 @@ INCLUDES = \ $(libjpeg2000_includes) \ $(libpng_includes) \ $(libcurl_includes) \ + $(imagemagick_includes) \ $(FREETYPE_CFLAGS) \ $(FONTCONFIG_CFLAGS) @@ -172,6 +182,7 @@ libpoppler_la_LIBADD = \ $(zlib_libs) \ $(libcurl_libs) \ $(libjpeg2000_libs) \ + $(imagemagick_libs) \ $(FREETYPE_LIBS) \ $(FONTCONFIG_LIBS) \ $(PTHREAD_LIBS) \ diff --git a/poppler/poppler-config.h.cmake b/poppler/poppler-config.h.cmake index e125f09..9b2f5bb 100644 --- a/poppler/poppler-config.h.cmake +++ b/poppler/poppler-config.h.cmake @@ -69,6 +69,11 @@ #cmakedefine ENABLE_ZLIB 1 #endif +/* Build against imagemagick. */ +#ifndef ENABLE_IMAGEMAGICK +#cmakedefine ENABLE_IMAGEMAGICK 1 +#endif + /* Define to 1 if you have the header file, and it defines `DIR'. */ #ifndef HAVE_DIRENT_H diff --git a/poppler/poppler-config.h.in b/poppler/poppler-config.h.in index 8f7cea0..871a464 100644 --- a/poppler/poppler-config.h.in +++ b/poppler/poppler-config.h.in @@ -69,6 +69,11 @@ #undef ENABLE_ZLIB #endif +/* Build against imagemagick. */ +#ifndef ENABLE_IMAGEMAGICK +#undef ENABLE_IMAGEMAGICK +#endif + /* Define to 1 if you have the header file, and it defines `DIR'. */ #ifndef HAVE_DIRENT_H diff --git a/splash/Makefile.am b/splash/Makefile.am index 4330c53..3617b9e 100644 --- a/splash/Makefile.am +++ b/splash/Makefile.am @@ -4,6 +4,7 @@ INCLUDES = \ $(libjpeg_includes) \ $(libtiff_includes) \ $(libpng_includes) \ + $(imagemagick_includes) \ $(FREETYPE_CFLAGS) # SplashBitmap includes JpegWriter.h, TiffWriter.h, PNGWriter.h @@ -19,6 +20,10 @@ if BUILD_LIBPNG libpng_includes = $(LIBPNG_CFLAGS) endif +if BUILD_IMAGEMAGICK +imagemagick_includes = $(IMAGEMAGICK_CFLAGS) +endif + noinst_LTLIBRARIES = libsplash.la if ENABLE_XPDF_HEADERS diff --git a/splash/Splash.cc b/splash/Splash.cc index e6559f4..04ae6ec 100644 --- a/splash/Splash.cc +++ b/splash/Splash.cc @@ -36,6 +36,7 @@ #include #include "goo/gmem.h" #include "goo/GooLikely.h" +#include "goo/MagickWriter.h" #include "poppler/Error.h" #include "SplashErrorCodes.h" #include "SplashMath.h" @@ -51,6 +52,7 @@ #include "Splash.h" #include + //------------------------------------------------------------------------ #define splashAAGamma 1.5 @@ -2963,6 +2965,10 @@ void Splash::arbitraryTransformMask(SplashImageMaskSource src, void *srcData, SplashBitmap *Splash::scaleMask(SplashImageMaskSource src, void *srcData, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight) { +#ifdef ENABLE_IMAGEMAGICK + return scaleMaskMagick(src, srcData, srcWidth, srcHeight, scaledWidth, scaledHeight); +#endif + SplashBitmap *dest; dest = new SplashBitmap(scaledWidth, scaledHeight, 1, splashModeMono8, @@ -3293,6 +3299,35 @@ void Splash::scaleMaskYuXu(SplashImageMaskSource src, void *srcData, gfree(lineBuf); } +void Splash::bitmapFromMaskSource(SplashImageMaskSource src, void *srcData, + int srcWidth, int srcHeight, + SplashBitmap *dest) { + Guchar *lineBuf; + Guint pix; + Guchar *destPtr0, *destPtr; + int y, x; + + // allocate buffers + lineBuf = (Guchar *)gmalloc(srcWidth); + + destPtr0 = dest->data; + for (y = 0; y < srcHeight; ++y) { + // read row from image + (*src)(srcData, lineBuf); + + for (x = 0; x < srcWidth; ++x) { + // compute the final pixel + pix = lineBuf[x] ? 255 : 0; + + // store the pixel + destPtr = destPtr0 + x; + *destPtr++ = (Guchar)pix; + } + destPtr0 += srcWidth; + } + gfree(lineBuf); +} + void Splash::blitMask(SplashBitmap *src, int xDest, int yDest, SplashClipResult clipRes) { SplashPipe pipe; @@ -3800,6 +3835,13 @@ SplashBitmap *Splash::scaleImage(SplashImageSource src, void *srcData, SplashColorMode srcMode, int nComps, GBool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight) { +#ifdef ENABLE_IMAGEMAGICK + return scaleImageMagick(src, srcData, + srcMode, nComps, + srcAlpha, srcWidth, srcHeight, + scaledWidth, scaledHeight); +#endif + SplashBitmap *dest; dest = new SplashBitmap(scaledWidth, scaledHeight, 1, srcMode, srcAlpha); @@ -4486,6 +4528,89 @@ void Splash::scaleImageYuXu(SplashImageSource src, void *srcData, gfree(lineBuf); } +void Splash::bitmapFromSource(SplashImageSource src, void *srcData, + SplashColorMode srcMode, int nComps, + GBool srcAlpha, int srcWidth, int srcHeight, + SplashBitmap *dest) { + Guchar *lineBuf, *alphaLineBuf; + Guint pix[splashMaxColorComps]; + Guint alpha; + Guchar *destPtr0, *destPtr, *destAlphaPtr0, *destAlphaPtr; + int x, y; + int i; + + // allocate buffers + lineBuf = (Guchar *)gmallocn(srcWidth, nComps); + if (srcAlpha) { + alphaLineBuf = (Guchar *)gmalloc(srcWidth); + } else { + alphaLineBuf = NULL; + } + + destPtr0 = dest->data; + destAlphaPtr0 = dest->alpha; + for (y = 0; y < srcHeight; ++y) { + // read row from image + (*src)(srcData, lineBuf, alphaLineBuf); + + for (x = 0; x < srcWidth; ++x) { + // compute the final pixel + for (i = 0; i < nComps; ++i) { + pix[i] = lineBuf[x * nComps + i]; + } + + // store the pixel + destPtr = destPtr0 + x * nComps; + switch (srcMode) { + case splashModeMono1: // mono1 is not allowed + break; + case splashModeMono8: + *destPtr++ = (Guchar)pix[0]; + break; + case splashModeRGB8: + *destPtr++ = (Guchar)pix[0]; + *destPtr++ = (Guchar)pix[1]; + *destPtr++ = (Guchar)pix[2]; + break; + case splashModeXBGR8: + *destPtr++ = (Guchar)pix[2]; + *destPtr++ = (Guchar)pix[1]; + *destPtr++ = (Guchar)pix[0]; + *destPtr++ = (Guchar)255; + break; + case splashModeBGR8: + *destPtr++ = (Guchar)pix[2]; + *destPtr++ = (Guchar)pix[1]; + *destPtr++ = (Guchar)pix[0]; + break; +#if SPLASH_CMYK + case splashModeCMYK8: + *destPtr++ = (Guchar)pix[0]; + *destPtr++ = (Guchar)pix[1]; + *destPtr++ = (Guchar)pix[2]; + *destPtr++ = (Guchar)pix[3]; + break; +#endif + } + + // process alpha + if (srcAlpha) { + alpha = alphaLineBuf[x]; + destAlphaPtr = destAlphaPtr0 + x; + *destAlphaPtr = (Guchar)alpha; + } + } + + destPtr0 += srcWidth * nComps; + if (srcAlpha) { + destAlphaPtr0 += srcWidth; + } + } + + gfree(alphaLineBuf); + gfree(lineBuf); +} + void Splash::vertFlipImage(SplashBitmap *img, int width, int height, int nComps) { Guchar *lineBuf; @@ -5864,3 +5989,156 @@ SplashError Splash::shadedFill(SplashPath *path, GBool hasBBox, delete xPath; return splashOk; } + +#ifdef ENABLE_IMAGEMAGICK +void Splash::bitmapToMagickImage(SplashBitmap *src, Magick::Image **dst) { + using namespace Magick; + int x, y; + PixelPacket *pixel_cache, *pixel; + ImgWriter *writer; + + writer = new MagickWriter(); + src->writeImgFile(writer, NULL, 0, 0); + *dst = ((MagickWriter*)writer)->image; + delete writer; + //(*dst)->verbose(1); + if (src->alpha) { + (*dst)->modifyImage(); + pixel_cache = (*dst)->getPixels(0, 0, src->width, src->height); + (*dst)->matte(1); + for (x = 0; x < src->width; x++) { + for (y = 0; y < src->height; y++) { + pixel = pixel_cache + src->width * y + x; + pixel->opacity = 255 - (src->alpha[y * src->width + x] * MaxRGB / 255); + } + } + (*dst)->syncPixels(); + } +} + +void Splash::magickImageToBitmap(Magick::Image *src, SplashBitmap **dst, SplashColorMode mode) { + using namespace Magick; + int width = src->columns(); + int height = src->rows(); + GBool alpha = src->matte(); + int x, y; + SplashColorPtr p; + unsigned char *pixels = new unsigned char[width * 4 * height]; + unsigned char *pixel; + const char *map = "RGBA"; + +#if SPLASH_CMYK + map = "CMYK"; +#endif + src->write(0, 0, width, height, map, CharPixel, pixels); + *dst = new SplashBitmap(width, height, 1, mode, alpha); + for (x = 0; x < width; x++) { + for (y = 0; y < height; y++) { + p = &((*dst)->data[y * (*dst)->rowSize + (*dst)->rowSize / width * x]); + pixel = pixels + width * 4 * y + x * 4; + switch (mode) { + case splashModeMono1: + // not handled + break; + case splashModeMono8: + p[0] = pixel[0]; + break; +#if SPLASH_CMYK + case splashModeCMYK8: + p[3] = pixel[3]; + // fall through +#endif + case splashModeRGB8: + p[0] = pixel[0]; + p[1] = pixel[1]; + p[2] = pixel[2]; + break; + case splashModeXBGR8: + p[3] = 255; + // fall through + case splashModeBGR8: + p[0] = pixel[2]; + p[1] = pixel[1]; + p[2] = pixel[0]; + break; + } + if (alpha && (*dst)->alpha) { + (*dst)->alpha[y * width + x] = pixel[3]; + } + } + } + delete[] pixels; +} + +SplashBitmap *Splash::scaleBitmapMagick(SplashBitmap *src_bitmap, int scaledWidth, int scaledHeight, GBool assume_mask=gFalse) { + SplashBitmap *dest; + Magick::Image *magick_image; + SplashBitmap *soft_mask = getSoftMask(); + + bitmapToMagickImage(src_bitmap, &magick_image); + // the resizing needs to happen in a linear colorspace: + // http://www.4p8.com/eric.brasseur/gamma.html + // http://www.imagemagick.org/Usage/resize/#resize_colorspace + magick_image->colorSpace(Magick::RGBColorspace); + Magick::Geometry geom(scaledWidth, scaledHeight); + geom.aspect(gTrue); + if (soft_mask || assume_mask) { + // avoid the black halo on images with soft masks + // a better solution would be to apply the mask before resizing + // but by the time we're in here the mask has already been resized + magick_image->filterType(Magick::GaussianFilter); + magick_image->resize(geom); + } else { +#if 0 +//#if MagickLibVersion > 0x669 + // the resize distortion is slightly better but slower and only available from version 6.6.9-2 + double args[] = {scaledWidth, scaledHeight}; + magick_image->distort(MagickCore::ResizeDistortion, 2, args); +#else + magick_image->resize(geom); +#endif + } + // going back to sRGB + magick_image->colorSpace(Magick::sRGBColorspace); + magickImageToBitmap(magick_image, &dest, src_bitmap->mode); + delete magick_image; + return dest; +} + +SplashBitmap *Splash::scaleImageMagick(SplashImageSource src, void *srcData, + SplashColorMode srcMode, int nComps, + GBool srcAlpha, int srcWidth, int srcHeight, + int scaledWidth, int scaledHeight) { + SplashBitmap *src_bitmap, *dest; + + src_bitmap = new SplashBitmap(srcWidth, srcHeight, 1, srcMode, srcAlpha); + bitmapFromSource(src, srcData, srcMode, nComps, srcAlpha, + srcWidth, srcHeight, src_bitmap); + // if we don't have to scale anything, just return src_bitmap + if (srcWidth == scaledWidth && srcHeight == scaledHeight) { + return src_bitmap; + } + + dest = scaleBitmapMagick(src_bitmap, scaledWidth, scaledHeight); + delete src_bitmap; + return dest; +} + +SplashBitmap *Splash::scaleMaskMagick(SplashImageMaskSource src, void *srcData, + int srcWidth, int srcHeight, + int scaledWidth, int scaledHeight) { + SplashBitmap *src_bitmap, *dest; + + src_bitmap = new SplashBitmap(srcWidth, srcHeight, 1, splashModeMono8, gFalse); + bitmapFromMaskSource(src, srcData, srcWidth, srcHeight, src_bitmap); + // if we don't have to scale anything, just return src_bitmap + if (srcWidth == scaledWidth && srcHeight == scaledHeight) { + return src_bitmap; + } + + dest = scaleBitmapMagick(src_bitmap, scaledWidth, scaledHeight, gTrue); + delete src_bitmap; + return dest; +} +#endif + diff --git a/splash/Splash.h b/splash/Splash.h index f4fb542..9e36f2f 100644 --- a/splash/Splash.h +++ b/splash/Splash.h @@ -32,6 +32,9 @@ #include "SplashTypes.h" #include "SplashClip.h" #include "SplashPattern.h" +#ifdef ENABLE_IMAGEMAGICK +#include +#endif class SplashBitmap; struct SplashGlyphBitmap; @@ -342,6 +345,9 @@ private: int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest); + void bitmapFromMaskSource(SplashImageMaskSource src, void *srcData, + int srcWidth, int srcHeight, + SplashBitmap *dest); void blitMask(SplashBitmap *src, int xDest, int yDest, SplashClipResult clipRes); SplashError arbitraryTransformImage(SplashImageSource src, void *srcData, @@ -373,6 +379,10 @@ private: GBool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest); + void bitmapFromSource(SplashImageSource src, void *srcData, + SplashColorMode srcMode, int nComps, + GBool srcAlpha, int srcWidth, int srcHeight, + SplashBitmap *dest); void vertFlipImage(SplashBitmap *img, int width, int height, int nComps); void blitImage(SplashBitmap *src, GBool srcAlpha, int xDest, int yDest, @@ -382,6 +392,19 @@ private: int w, int h); void dumpPath(SplashPath *path); void dumpXPath(SplashXPath *path); + #ifdef ENABLE_IMAGEMAGICK + void bitmapToMagickImage(SplashBitmap *src, Magick::Image **dst); + void magickImageToBitmap(Magick::Image *src, SplashBitmap **dst, SplashColorMode mode); + SplashBitmap *scaleBitmapMagick(SplashBitmap *src_bitmap, int scaledWidth, int scaledHeight, + GBool assume_mask); + SplashBitmap *scaleImageMagick(SplashImageSource src, void *srcData, + SplashColorMode srcMode, int nComps, + GBool srcAlpha, int srcWidth, int srcHeight, + int scaledWidth, int scaledHeight); + SplashBitmap *scaleMaskMagick(SplashImageMaskSource src, void *srcData, + int srcWidth, int srcHeight, + int scaledWidth, int scaledHeight); + #endif static SplashPipeResultColorCtrl pipeResultColorNoAlphaBlend[]; static SplashPipeResultColorCtrl pipeResultColorAlphaNoBlend[]; diff --git a/utils/Makefile.am b/utils/Makefile.am index d56cc9c..45becc1 100644 --- a/utils/Makefile.am +++ b/utils/Makefile.am @@ -15,9 +15,14 @@ INCLUDES = \ -I$(top_srcdir)/goo \ -I$(top_srcdir)/utils \ -I$(top_srcdir)/poppler \ + $(imagemagick_includes) \ $(UTILS_CFLAGS) \ $(PDFTOCAIRO_CFLAGS) +if BUILD_IMAGEMAGICK +imagemagick_includes = $(IMAGEMAGICK_CFLAGS) +endif + LDADD = \ $(top_builddir)/poppler/libpoppler.la \ $(UTILS_LIBS)