/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id: AFPImageHandlerRenderedImage.java 1325277 2012-04-12 14:17:05Z phancock $ */
package org.apache.fop.render.afp;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferByte;
import java.awt.image.MultiPixelPackedSampleModel;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.SampleModel;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.xmlgraphics.image.loader.Image;
import org.apache.xmlgraphics.image.loader.ImageFlavor;
import org.apache.xmlgraphics.image.loader.ImageInfo;
import org.apache.xmlgraphics.image.loader.ImageSize;
import org.apache.xmlgraphics.image.loader.impl.ImageRendered;
import org.apache.xmlgraphics.image.writer.ImageWriter;
import org.apache.xmlgraphics.image.writer.ImageWriterParams;
import org.apache.xmlgraphics.image.writer.ImageWriterRegistry;
import org.apache.xmlgraphics.ps.ImageEncodingHelper;
import org.apache.xmlgraphics.util.MimeConstants;
import org.apache.xmlgraphics.util.UnitConv;
import org.apache.fop.afp.AFPDataObjectInfo;
import org.apache.fop.afp.AFPImageObjectInfo;
import org.apache.fop.afp.AFPObjectAreaInfo;
import org.apache.fop.afp.AFPPaintingState;
import org.apache.fop.afp.AFPResourceInfo;
import org.apache.fop.afp.AFPResourceManager;
import org.apache.fop.afp.ioca.ImageContent;
import org.apache.fop.afp.modca.ResourceObject;
import org.apache.fop.render.ImageHandler;
import org.apache.fop.render.RenderingContext;
import org.apache.fop.util.bitmap.BitmapImageUtil;
/**
* PDFImageHandler implementation which handles RenderedImage instances.
*/
public class AFPImageHandlerRenderedImage extends AFPImageHandler implements ImageHandler {
/** logging instance */
private static Log log = LogFactory.getLog(AFPImageHandlerRenderedImage.class);
private static final ImageFlavor[] FLAVORS = new ImageFlavor[] {
ImageFlavor.BUFFERED_IMAGE,
ImageFlavor.RENDERED_IMAGE
};
private void setDefaultResourceLevel(AFPImageObjectInfo imageObjectInfo,
AFPResourceManager resourceManager) {
AFPResourceInfo resourceInfo = imageObjectInfo.getResourceInfo();
if (!resourceInfo.levelChanged()) {
resourceInfo.setLevel(resourceManager.getResourceLevelDefaults()
.getDefaultResourceLevel(ResourceObject.TYPE_IMAGE));
}
}
/** {@inheritDoc} */
@Override
protected AFPDataObjectInfo createDataObjectInfo() {
return new AFPImageObjectInfo();
}
/** {@inheritDoc} */
public int getPriority() {
return 300;
}
/** {@inheritDoc} */
public Class getSupportedImageClass() {
return ImageRendered.class;
}
/** {@inheritDoc} */
public ImageFlavor[] getSupportedImageFlavors() {
return FLAVORS;
}
/** {@inheritDoc} */
public void handleImage(RenderingContext context, Image image, Rectangle pos)
throws IOException {
AFPRenderingContext afpContext = (AFPRenderingContext)context;
AFPImageObjectInfo imageObjectInfo = (AFPImageObjectInfo)createDataObjectInfo();
AFPPaintingState paintingState = afpContext.getPaintingState();
// set resource information
setResourceInformation(imageObjectInfo,
image.getInfo().getOriginalURI(),
afpContext.getForeignAttributes());
setDefaultResourceLevel(imageObjectInfo, afpContext.getResourceManager());
// Positioning
imageObjectInfo.setObjectAreaInfo(createObjectAreaInfo(paintingState, pos));
Dimension targetSize = pos.getSize();
// Image content
ImageRendered imageRend = (ImageRendered)image;
RenderedImageEncoder encoder = new RenderedImageEncoder(imageRend, targetSize);
encoder.prepareEncoding(imageObjectInfo, paintingState);
boolean included = afpContext.getResourceManager().tryIncludeObject(imageObjectInfo);
if (!included) {
long start = System.currentTimeMillis();
//encode only if the same image has not been encoded, yet
encoder.encodeImage(imageObjectInfo, paintingState);
if (log.isDebugEnabled()) {
long duration = System.currentTimeMillis() - start;
log.debug("Image encoding took " + duration + "ms.");
}
// Create image
afpContext.getResourceManager().createObject(imageObjectInfo);
}
}
/** {@inheritDoc} */
public boolean isCompatible(RenderingContext targetContext, Image image) {
return (image == null || image instanceof ImageRendered)
&& targetContext instanceof AFPRenderingContext;
}
private static final class RenderedImageEncoder {
private enum FunctionSet {
FS10(MimeConstants.MIME_AFP_IOCA_FS10),
FS11(MimeConstants.MIME_AFP_IOCA_FS11),
FS45(MimeConstants.MIME_AFP_IOCA_FS45);
private String mimeType;
FunctionSet(String mimeType) {
this.mimeType = mimeType;
}
private String getMimeType() {
return mimeType;
}
};
private ImageRendered imageRendered;
private Dimension targetSize;
private boolean useFS10;
private int maxPixelSize;
private boolean usePageSegments;
private boolean resample;
private Dimension resampledDim;
private ImageSize intrinsicSize;
private ImageSize effIntrinsicSize;
private RenderedImageEncoder(ImageRendered imageRendered, Dimension targetSize) {
this.imageRendered = imageRendered;
this.targetSize = targetSize;
}
private void prepareEncoding(AFPImageObjectInfo imageObjectInfo,
AFPPaintingState paintingState) {
maxPixelSize = paintingState.getBitsPerPixel();
if (paintingState.isColorImages()) {
if (paintingState.isCMYKImagesSupported()) {
maxPixelSize *= 4; //CMYK is maximum
} else {
maxPixelSize *= 3; //RGB is maximum
}
}
RenderedImage renderedImage = imageRendered.getRenderedImage();
useFS10 = (maxPixelSize == 1) || BitmapImageUtil.isMonochromeImage(renderedImage);
ImageInfo imageInfo = imageRendered.getInfo();
this.intrinsicSize = imageInfo.getSize();
this.effIntrinsicSize = intrinsicSize;
AFPResourceInfo resourceInfo = imageObjectInfo.getResourceInfo();
this.usePageSegments = useFS10 && !resourceInfo.getLevel().isInline();
if (usePageSegments) {
//The image may need to be resized/resampled for use as a page segment
int resolution = paintingState.getResolution();
this.resampledDim = new Dimension(
(int)Math.ceil(UnitConv.mpt2px(targetSize.getWidth(), resolution)),
(int)Math.ceil(UnitConv.mpt2px(targetSize.getHeight(), resolution)));
resourceInfo.setImageDimension(resampledDim);
//Only resample/downsample if image is smaller than its intrinsic size
//to make print file smaller
this.resample = resampledDim.width < renderedImage.getWidth()
&& resampledDim.height < renderedImage.getHeight();
if (resample) {
effIntrinsicSize = new ImageSize(
resampledDim.width, resampledDim.height, resolution);
}
}
//Update image object info
imageObjectInfo.setDataHeightRes((int)Math.round(
effIntrinsicSize.getDpiHorizontal() * 10));
imageObjectInfo.setDataWidthRes((int)Math.round(
effIntrinsicSize.getDpiVertical() * 10));
imageObjectInfo.setDataHeight(effIntrinsicSize.getHeightPx());
imageObjectInfo.setDataWidth(effIntrinsicSize.getWidthPx());
// set object area info
int resolution = paintingState.getResolution();
AFPObjectAreaInfo objectAreaInfo = imageObjectInfo.getObjectAreaInfo();
objectAreaInfo.setWidthRes(resolution);
objectAreaInfo.setHeightRes(resolution);
}
private AFPDataObjectInfo encodeImage
(AFPImageObjectInfo imageObjectInfo,
AFPPaintingState paintingState)
throws IOException {
RenderedImage renderedImage = imageRendered.getRenderedImage();
FunctionSet functionSet = useFS10 ? FunctionSet.FS10 : FunctionSet.FS11;
if (usePageSegments) {
assert resampledDim != null;
//Resize, optionally resample and convert image
imageObjectInfo.setCreatePageSegment(true);
float ditheringQuality = paintingState.getDitheringQuality();
if (this.resample) {
if (log.isDebugEnabled()) {
log.debug("Resample from " + intrinsicSize.getDimensionPx()
+ " to " + resampledDim);
}
renderedImage = BitmapImageUtil.convertToMonochrome(renderedImage,
resampledDim, ditheringQuality);
} else if (ditheringQuality >= 0.5f) {
renderedImage = BitmapImageUtil.convertToMonochrome(renderedImage,
intrinsicSize.getDimensionPx(), ditheringQuality);
}
}
//TODO To reduce AFP file size, investigate using a compression scheme.
//Currently, all image data is uncompressed.
ColorModel cm = renderedImage.getColorModel();
if (log.isTraceEnabled()) {
log.trace("ColorModel: " + cm);
}
int pixelSize = cm.getPixelSize();
if (cm.hasAlpha()) {
pixelSize -= 8;
}
byte[] imageData = null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
boolean allowDirectEncoding = true;
if (allowDirectEncoding && (pixelSize <= maxPixelSize)) {
//Attempt to encode without resampling the image
ImageEncodingHelper helper = new ImageEncodingHelper(renderedImage,
pixelSize == 32);
ColorModel encodedColorModel = helper.getEncodedColorModel();
boolean directEncode = true;
if (helper.getEncodedColorModel().getPixelSize() > maxPixelSize) {
directEncode = false; //pixel size needs to be reduced
}
if (BitmapImageUtil.getColorIndexSize(renderedImage) > 2) {
directEncode = false; //Lookup tables are not implemented, yet
}
if (useFS10
&& BitmapImageUtil.isMonochromeImage(renderedImage)
&& BitmapImageUtil.isZeroBlack(renderedImage)) {
directEncode = false;
//need a special method to invert the bit-stream since setting the
//subtractive mode in AFP alone doesn't seem to do the trick.
if (encodeInvertedBilevel(helper, imageObjectInfo, baos)) {
imageData = baos.toByteArray();
}
}
if (directEncode) {
log.debug("Encoding image directly...");
imageObjectInfo.setBitsPerPixel(encodedColorModel.getPixelSize());
if (pixelSize == 32) {
functionSet = FunctionSet.FS45; //IOCA FS45 required for CMYK
}
//Lossy or loss-less?
if (!paintingState.canEmbedJpeg()
&& paintingState.getBitmapEncodingQuality() < 1.0f) {
try {
if (log.isDebugEnabled()) {
log.debug("Encoding using baseline DCT (JPEG, q="
+ paintingState.getBitmapEncodingQuality() + ")...");
}
encodeToBaselineDCT(renderedImage,
paintingState.getBitmapEncodingQuality(),
paintingState.getResolution(),
baos);
imageObjectInfo.setCompression(ImageContent.COMPID_JPEG);
} catch (IOException ioe) {
//Some JPEG codecs cannot encode CMYK
helper.encode(baos);
}
} else {
helper.encode(baos);
}
imageData = baos.toByteArray();
}
}
if (imageData == null) {
log.debug("Encoding image via RGB...");
imageData = encodeViaRGB(renderedImage, imageObjectInfo, paintingState, baos);
}
// Should image be FS45?
if (paintingState.getFS45()) {
functionSet = FunctionSet.FS45;
}
//Wrapping 300+ resolution FS11 IOCA in a page segment is apparently necessary(?)
imageObjectInfo.setCreatePageSegment(
(functionSet.equals(FunctionSet.FS11) || functionSet.equals(FunctionSet.FS45))
&& paintingState.getWrapPSeg()
);
imageObjectInfo.setMimeType(functionSet.getMimeType());
imageObjectInfo.setData(imageData);
return imageObjectInfo;
}
private byte[] encodeViaRGB(RenderedImage renderedImage,
AFPImageObjectInfo imageObjectInfo, AFPPaintingState paintingState,
ByteArrayOutputStream baos) throws IOException {
byte[] imageData;
//Convert image to 24bit RGB
ImageEncodingHelper.encodeRenderedImageAsRGB(renderedImage, baos);
imageData = baos.toByteArray();
imageObjectInfo.setBitsPerPixel(24);
boolean colorImages = paintingState.isColorImages();
imageObjectInfo.setColor(colorImages);
// convert to grayscale
if (!colorImages) {
log.debug("Converting RGB image to grayscale...");
baos.reset();
int bitsPerPixel = paintingState.getBitsPerPixel();
imageObjectInfo.setBitsPerPixel(bitsPerPixel);
//TODO this should be done off the RenderedImage to avoid buffering the
//intermediate 24bit image
ImageEncodingHelper.encodeRGBAsGrayScale(
imageData, renderedImage.getWidth(), renderedImage.getHeight(),
bitsPerPixel, baos);
imageData = baos.toByteArray();
if (bitsPerPixel == 1) {
imageObjectInfo.setSubtractive(true);
}
}
return imageData;
}
/**
* Efficiently encodes a bi-level image in inverted form as a plain bit-stream.
* @param helper the image encoding helper used to analyze the image
* @param imageObjectInfo the AFP image object
* @param out the output stream
* @return true if the image was encoded, false if there was something prohibiting that
* @throws IOException if an I/O error occurs
*/
private boolean encodeInvertedBilevel(ImageEncodingHelper helper,
AFPImageObjectInfo imageObjectInfo, OutputStream out) throws IOException {
RenderedImage renderedImage = helper.getImage();
if (!BitmapImageUtil.isMonochromeImage(renderedImage)) {
throw new IllegalStateException("This method only supports binary images!");
}
int tiles = renderedImage.getNumXTiles() * renderedImage.getNumYTiles();
if (tiles > 1) {
return false;
}
SampleModel sampleModel = renderedImage.getSampleModel();
SampleModel expectedSampleModel = new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE,
renderedImage.getWidth(), renderedImage.getHeight(), 1);
if (!expectedSampleModel.equals(sampleModel)) {
return false; //Pixels are not packed
}
imageObjectInfo.setBitsPerPixel(1);
Raster raster = renderedImage.getTile(0, 0);
DataBuffer buffer = raster.getDataBuffer();
if (buffer instanceof DataBufferByte) {
DataBufferByte byteBuffer = (DataBufferByte)buffer;
log.debug("Encoding image as inverted bi-level...");
byte[] rawData = byteBuffer.getData();
int remaining = rawData.length;
int pos = 0;
byte[] data = new byte[4096];
while (remaining > 0) {
int size = Math.min(remaining, data.length);
for (int i = 0; i < size; i++) {
data[i] = (byte)~rawData[pos]; //invert bits
pos++;
}
out.write(data, 0, size);
remaining -= size;
}
return true;
}
return false;
}
private void encodeToBaselineDCT(RenderedImage image,
float quality, int resolution, OutputStream out) throws IOException {
ImageWriter writer = ImageWriterRegistry.getInstance().getWriterFor("image/jpeg");
ImageWriterParams params = new ImageWriterParams();
params.setJPEGQuality(quality, true);
params.setResolution(resolution);
writer.writeImage(image, out, params);
}
}
}