下面列出了怎么用javax.imageio.plugins.jpeg.JPEGImageWriteParam的API类实例代码及写法，或者点击链接到github查看源代码。
/**
* This static method writes the indicated renderedImage (BufferedImage)
* to the indicated file.
*
* @param writeFile The File that shall receive the jpg data
* @param renderedImage The RenderedImage (BufferedImage) to be written
* @param jpgQuality The quality with which to compress to jpg
*/
public static void writeJpg(File writeFile, RenderedImage renderedImage, float jpgQuality) {
Iterator writers = ImageIO.getImageWritersByFormatName("jpg");
ImageWriter writer = (ImageWriter) writers.next();
JPEGImageWriteParam params = new JPEGImageWriteParam(null);
params.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
params.setCompressionQuality(jpgQuality);
params.setProgressiveMode(ImageWriteParam.MODE_DISABLED);
params.setDestinationType(new ImageTypeSpecifier(java.awt.image.IndexColorModel.getRGBdefault(),
IndexColorModel.getRGBdefault().createCompatibleSampleModel(16, 16)));
try (ImageOutputStream ios = ImageIO.createImageOutputStream(new FileOutputStream(writeFile))) {
writer.setOutput(ios);
writer.write(null, new IIOImage(renderedImage, null, null), params);
ios.close();
} catch (IOException e) {
// Tools.log("ScalablePicture.writeJpg caught IOException: " + e.getMessage() + "\nwhile writing " +
// writeFile.toString());
e.printStackTrace();
}
// writer = null;
writer.dispose(); // 1.4.1 documentation says to do this.
}
/**
* This method creates a thumbnail from the given byte-array. The values for
* x and y are fetched from DB. Also the quality of the thumbnail is fetched
* from DB and the type of the target image.
*
* @return
*/
byte[] createThumbnail(byte[] sourceImage) {
ByteArrayOutputStream out = null;
float quality = 0.4f;
try (ImageOutputStream ios = ImageIO.createImageOutputStream(out)) {
BufferedImage buff = ImageIO.read(new ByteArrayInputStream(sourceImage));
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpg").next();
writer.setOutput(ios);
ImageWriteParam iwparam = new JPEGImageWriteParam(Locale.getDefault());
iwparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwparam.setCompressionQuality(quality);
writer.write(null, new IIOImage(buff, null, null), iwparam);
ios.flush();
writer.dispose();
ios.close();
} catch (IOException e) {
logger.error("Error creating thumbnail", e);
}
return null;
}
private static ImageWriter getJPEGImageWriter() throws IOException
{
ImageWriter writer = null;
Iterator<ImageWriter> writers = ImageIO.getImageWritersBySuffix("jpeg");
while (writers.hasNext())
{
if (writer != null)
{
writer.dispose();
}
writer = writers.next();
if (writer == null)
{
continue;
}
// PDFBOX-3566: avoid CLibJPEGImageWriter, which is not a JPEGImageWriteParam
if (writer.getDefaultWriteParam() instanceof JPEGImageWriteParam)
{
return writer;
}
}
throw new IOException("No ImageWriter found for JPEG format");
}
private static void writeJpegImage(ImageHolder image, OutputStream os) throws OpenStegoException {
try {
JPEGImageWriteParam jpegParams = new JPEGImageWriteParam(null);
jpegParams.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
jpegParams.setOptimizeHuffmanTables(true);
Float qual = UserPreferences.getFloat("image.writer.jpeg.quality");
if (qual == null) {
qual = 0.75f;
}
jpegParams.setCompressionQuality(qual);
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpg").next();
writer.setOutput(ImageIO.createImageOutputStream(os));
writer.write(null, new IIOImage(image.getImage(), null, image.getMetadata()), jpegParams);
} catch (IOException e) {
throw new OpenStegoException(e);
}
}
/** {@inheritDoc} */
@Override
protected ImageWriteParam getDefaultWriteParam(
ImageWriter iiowriter, RenderedImage image,
ImageWriterParams params) {
JPEGImageWriteParam param = new JPEGImageWriteParam(iiowriter.getLocale());
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionQuality(params.getJPEGQuality());
if (params.getCompressionMethod() != null
&& !"JPEG".equals(params.getCompressionMethod())) {
throw new IllegalArgumentException(
"No compression method other than JPEG is supported for JPEG output!");
}
if (params.getJPEGForceBaseline()) {
param.setProgressiveMode(JPEGImageWriteParam.MODE_DISABLED);
}
return param;
}
@Override
public void writeImageFile(OutputStream outStream, String format, ByteBuffer imageData, int width, int height) throws IOException {
BufferedImage awtImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
Screenshots.convertScreenShot2(imageData.asIntBuffer(), awtImage);
ImageWriter writer = ImageIO.getImageWritersByFormatName(format).next();
ImageWriteParam writeParam = writer.getDefaultWriteParam();
if (format.equals("jpg")) {
JPEGImageWriteParam jpegParam = (JPEGImageWriteParam) writeParam;
jpegParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
jpegParam.setCompressionQuality(0.95f);
}
awtImage = verticalFlip(awtImage);
ImageOutputStream imgOut = new MemoryCacheImageOutputStream(outStream);
writer.setOutput(imgOut);
IIOImage outputImage = new IIOImage(awtImage, null, null);
try {
writer.write(null, outputImage, writeParam);
} finally {
imgOut.close();
writer.dispose();
}
}
public boolean saveImage_Jpeg(String file, int width, int height, int dpi) {
double scaleFactor = dpi / 72.0;
BufferedImage bufferedImage = new BufferedImage((int)(width * scaleFactor), (int)(height * scaleFactor), BufferedImage.TYPE_INT_RGB);
Graphics2D g = bufferedImage.createGraphics();
AffineTransform at = g.getTransform();
at.scale(scaleFactor, scaleFactor);
g.setTransform(at);
paintGraphics(g, width, height);
try {
// Image writer
ImageWriter imageWriter = ImageIO.getImageWritersBySuffix("jpeg").next();
ImageOutputStream ios = ImageIO.createImageOutputStream(new File(file));
imageWriter.setOutput(ios);
// Compression
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) imageWriter.getDefaultWriteParam();
jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(0.85f);
// Metadata (dpi)
IIOMetadata data = imageWriter.getDefaultImageMetadata(new ImageTypeSpecifier(bufferedImage), jpegParams);
Element tree = (Element) data.getAsTree("javax_imageio_jpeg_image_1.0");
Element jfif = (Element) tree.getElementsByTagName("app0JFIF").item(0);
jfif.setAttribute("Xdensity", Integer.toString(dpi));
jfif.setAttribute("Ydensity", Integer.toString(dpi));
jfif.setAttribute("resUnits", "1"); // density is dots per inch
data.setFromTree("javax_imageio_jpeg_image_1.0", tree);
// Write and clean up
imageWriter.write(null, new IIOImage(bufferedImage, null, data), jpegParams);
ios.close();
imageWriter.dispose();
} catch (Exception e) {
return false;
}
g.dispose();
return true;
}
private boolean saveImage_Jpeg(String file, int width, int height, int dpi) {
double scaleFactor = dpi / 72.0;
BufferedImage bufferedImage = new BufferedImage((int)(width * scaleFactor), (int)(height * scaleFactor), BufferedImage.TYPE_INT_RGB);
Graphics2D g = bufferedImage.createGraphics();
AffineTransform at = g.getTransform();
at.scale(scaleFactor, scaleFactor);
g.setTransform(at);
paintGraphics(g);
try {
// Image writer
ImageWriter imageWriter = ImageIO.getImageWritersBySuffix("jpeg").next();
ImageOutputStream ios = ImageIO.createImageOutputStream(new File(file));
imageWriter.setOutput(ios);
// Compression
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) imageWriter.getDefaultWriteParam();
jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(0.85f);
// Metadata (dpi)
IIOMetadata data = imageWriter.getDefaultImageMetadata(new ImageTypeSpecifier(bufferedImage), jpegParams);
Element tree = (Element) data.getAsTree("javax_imageio_jpeg_image_1.0");
Element jfif = (Element) tree.getElementsByTagName("app0JFIF").item(0);
jfif.setAttribute("Xdensity", Integer.toString(dpi));
jfif.setAttribute("Ydensity", Integer.toString(dpi));
jfif.setAttribute("resUnits", "1"); // density is dots per inch
data.setFromTree("javax_imageio_jpeg_image_1.0", tree);
// Write and clean up
imageWriter.write(null, new IIOImage(bufferedImage, null, data), jpegParams);
ios.close();
imageWriter.dispose();
} catch (Exception e) {
return false;
}
g.dispose();
return true;
}
@Override
public BufferedImage apply(BufferedImage img) {
if(compressionLevel == 0f)
return img;
try {
ImageWriter iw = ImageIO.getImageWritersByFormatName("jpeg").next();
JPEGImageWriteParam iwp = (JPEGImageWriteParam) iw.getDefaultWriteParam();
iwp.setOptimizeHuffmanTables(false);
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setProgressiveMode(ImageWriteParam.MODE_DISABLED);
iwp.setCompressionQuality(1f-compressionLevel);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
iw.setOutput(new MemoryCacheImageOutputStream(baos));
IIOImage outputImage = new IIOImage(img, null, null);
iw.write(null, outputImage, iwp);
iw.dispose();
baos.flush();
byte[] returnImage = baos.toByteArray();
baos.close();
BufferedImage img2 = ImageIO.read(new ByteArrayInputStream(returnImage));
if(img2 == null)
throw new Exception();
else
img = img2;
} catch (Exception e) {
e.printStackTrace();
}
return img;
}
public static void main(String[] args) {
ImageWriteParam iwp = new JPEGImageWriteParam(null);
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
float[] vals = iwp.getCompressionQualityValues();
String[] descs = iwp.getCompressionQualityDescriptions();
if (vals.length != (descs.length + 1)) {
throw new RuntimeException("Test failed: Values array is not " +
"one larger than descriptions array");
}
}
public static void main(String[] args) {
ImageWriteParam iwp = new JPEGImageWriteParam(null);
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
float[] vals = iwp.getCompressionQualityValues();
String[] descs = iwp.getCompressionQualityDescriptions();
if (vals.length != (descs.length + 1)) {
throw new RuntimeException("Test failed: Values array is not " +
"one larger than descriptions array");
}
}
private static ImageAndResolution convertToInputStreamJPG(BufferedImage buffImage, int dpi) throws IOException {
ImageWriter writer = getImageWriter("jpeg");
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) writer.getDefaultWriteParam();
jpegParams.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(1);
ImageTypeSpecifier typeSpecifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
IIOMetadata metadata = writer.getDefaultImageMetadata(typeSpecifier, jpegParams);
initDpiJPG(metadata, dpi);
return getImageAndResolution(buffImage, dpi, writer, jpegParams, metadata);
}
@Override
public void writeBufferedImage(BufferedImage bufferedImage, float quality, int dpi, String formatName, File targetFile) throws Exception {
if (formatName.equalsIgnoreCase("jpg") || formatName.equalsIgnoreCase("jpeg")) {
JPEGImageWriter imageWriter = (JPEGImageWriter) ImageIO.getImageWritersBySuffix(formatName).next();
ImageWriteParam writeParam = imageWriter.getDefaultWriteParam();
ImageTypeSpecifier typeSpecifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
IIOMetadata metadata = imageWriter.getDefaultImageMetadata(typeSpecifier, writeParam);
if (formatName.equalsIgnoreCase("jpg") || formatName.equalsIgnoreCase("jpeg")) {
Element tree = (Element) metadata.getAsTree("javax_imageio_jpeg_image_1.0");
Element jfif = (Element) tree.getElementsByTagName("app0JFIF").item(0);
jfif.setAttribute("Xdensity", Integer.toString(dpi));
jfif.setAttribute("Ydensity", Integer.toString(dpi));
jfif.setAttribute("resUnits", "1");
metadata.setFromTree("javax_imageio_jpeg_image_1.0", tree);
}
if (quality >= 0 && quality <= 1f) {
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) imageWriter.getDefaultWriteParam();
jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(quality);
}
FileOutputStream os = new FileOutputStream(targetFile);
final ImageOutputStream stream = ImageIO.createImageOutputStream(os);
try {
imageWriter.setOutput(stream);
imageWriter.write(metadata, new IIOImage(bufferedImage, null, metadata), writeParam);
} finally {
stream.close();
}
} else {
writeBufferedImage(bufferedImage, formatName, targetFile);
}
}
@Override
public void writeBufferedImage(BufferedImage bufferedImage, float quality, int dpi, String formatName, File targetFile) throws Exception {
System.out.println("Saving " + targetFile.getPath());
if (formatName.equalsIgnoreCase("jpg") || formatName.equalsIgnoreCase("jpeg")) {
JPEGImageWriter imageWriter = (JPEGImageWriter) ImageIO.getImageWritersBySuffix(formatName).next();
ImageWriteParam writeParam = imageWriter.getDefaultWriteParam();
ImageTypeSpecifier typeSpecifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
IIOMetadata metadata = imageWriter.getDefaultImageMetadata(typeSpecifier, writeParam);
if (formatName.equalsIgnoreCase("jpg") || formatName.equalsIgnoreCase("jpeg")) {
Element tree = (Element) metadata.getAsTree("javax_imageio_jpeg_image_1.0");
Element jfif = (Element) tree.getElementsByTagName("app0JFIF").item(0);
jfif.setAttribute("Xdensity", Integer.toString(dpi));
jfif.setAttribute("Ydensity", Integer.toString(dpi));
jfif.setAttribute("resUnits", "1");
metadata.setFromTree("javax_imageio_jpeg_image_1.0", tree);
}
if (quality >= 0 && quality <= 1f) {
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) imageWriter.getDefaultWriteParam();
jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(quality);
}
FileOutputStream os = new FileOutputStream(targetFile);
final ImageOutputStream stream = ImageIO.createImageOutputStream(os);
try {
imageWriter.setOutput(stream);
imageWriter.write(metadata, new IIOImage(bufferedImage, null, metadata), writeParam);
} finally {
stream.close();
}
} else {
writeBufferedImage(bufferedImage, formatName, targetFile);
}
}
@Override
ImageWriteParam newImageWriterParams(PdfToJpegParameters params) {
JPEGImageWriteParam param = new JPEGImageWriteParam(writer.getLocale());
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionQuality((float) params.getQuality() / 100);
return param;
}
/**
* Creates a time series chart diagram and writes it to the OutputStream.
*/
public void producePresentation(Map<String, OXFFeatureCollection> entireCollMap,
DesignOptions options, FileOutputStream out, boolean compress) throws OXFException,
IOException {
// render features:
int width = options.getWidth();
int height = options.getHeight();
Calendar begin = Calendar.getInstance();
begin.setTimeInMillis(options.getBegin());
Calendar end = Calendar.getInstance();
end.setTimeInMillis(options.getEnd());
DiagramRenderer renderer = new DiagramRenderer(false);
JFreeChart diagramChart = renderer.renderChart(entireCollMap, options, begin, end, compress);
diagramChart.removeLegend();
// draw chart into image:
BufferedImage diagramImage = new BufferedImage(width, height, TYPE_INT_RGB);
Graphics2D chartGraphics = diagramImage.createGraphics();
chartGraphics.setColor(Color.white);
chartGraphics.fillRect(0, 0, width, height);
diagramChart.draw(chartGraphics, new Rectangle2D.Float(0, 0, width, height));
JPEGImageWriteParam p = new JPEGImageWriteParam(null);
p.setCompressionMode(JPEGImageWriteParam.MODE_DEFAULT);
write(diagramImage, FORMAT, out);
}
public void createLegend(DesignOptions options, OutputStream out) throws OXFException, IOException {
int topMargin = 10;
int leftMargin = 30;
int iconWidth = 15;
int iconHeight = 15;
int verticalSpaceBetweenEntries = 20;
int horizontalSpaceBetweenIconAndText = 15;
DesignDescriptionList ddList = buildUpDesignDescriptionList(options);
int width = 800;
int height = topMargin + (ddList.size() * (iconHeight + verticalSpaceBetweenEntries));
BufferedImage legendImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
Graphics2D legendGraphics = legendImage.createGraphics();
legendGraphics.setColor(Color.white);
legendGraphics.fillRect(0, 0, width, height);
int offset = 0;
for (RenderingDesign dd : ddList.getAllDesigns()) {
int yPos = topMargin + offset * iconHeight + offset * verticalSpaceBetweenEntries;
// icon:
legendGraphics.setColor(dd.getColor());
legendGraphics.fillRect(leftMargin, yPos, iconWidth, iconHeight);
// text:
legendGraphics.setColor(Color.black);
legendGraphics.drawString(dd.getFeature().getLabel() + " - "
+ dd.getLabel(), leftMargin + iconWidth
+ horizontalSpaceBetweenIconAndText, yPos + iconHeight);
offset++;
}
JPEGImageWriteParam p = new JPEGImageWriteParam(null);
p.setCompressionMode(JPEGImageWriteParam.MODE_DEFAULT);
write(legendImage, FORMAT, out);
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
public static String[] getJpegCompressionTypes() {
return new JPEGImageWriteParam(null).getCompressionTypes();
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
/**
* 缩放gif图片
*
* @param originalFile
* 原图片
* @param resizedFile
* 缩放后的图片
* @param newWidth
* 宽度
* @param quality
* 缩放比例 (等比例)
*
* @throws IOException
*/
private static void resize(File originalFile, File resizedFile, int newWidth, float quality) throws IOException {
if (quality < 0 || quality > 1) {
throw new IllegalArgumentException("Quality has to be between 0 and 1");
}
ImageIcon ii = new ImageIcon(originalFile.getCanonicalPath());
Image i = ii.getImage();
Image resizedImage = null;
int iWidth = i.getWidth(null);
int iHeight = i.getHeight(null);
if (iWidth > iHeight) {
resizedImage = i.getScaledInstance(newWidth, (newWidth * iHeight) / iWidth, Image.SCALE_SMOOTH);
} else {
resizedImage = i.getScaledInstance((newWidth * iWidth) / iHeight, newWidth, Image.SCALE_SMOOTH);
}
// This code ensures that all the pixels in the image are loaded.
Image temp = new ImageIcon(resizedImage).getImage();
// Create the buffered image.
BufferedImage bufferedImage = new BufferedImage(temp.getWidth(null), temp.getHeight(null), BufferedImage.TYPE_INT_RGB);
// Copy image to buffered image.
Graphics g = bufferedImage.createGraphics();
// Clear background and paint the image.
g.setColor(Color.white);
g.fillRect(0, 0, temp.getWidth(null), temp.getHeight(null));
g.drawImage(temp, 0, 0, null);
g.dispose();
// Soften.
float softenFactor = 0.05f;
float[] softenArray = {0, softenFactor, 0, softenFactor, 1 - (softenFactor * 4), softenFactor, 0, softenFactor, 0};
Kernel kernel = new Kernel(3, 3, softenArray);
ConvolveOp cOp = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
bufferedImage = cOp.filter(bufferedImage, null);
// Write the jpeg to a file.
try (
FileOutputStream out = new FileOutputStream(resizedFile)) {
ImageWriter imageWriter = ImageIO.getImageWritersBySuffix("jpg").next();
ImageOutputStream ios = ImageIO.createImageOutputStream(out);
imageWriter.setOutput(ios);
//and metadata
IIOMetadata imageMetaData = imageWriter.getDefaultImageMetadata(new ImageTypeSpecifier(bufferedImage), null);
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) imageWriter.getDefaultWriteParam();
jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(quality);
imageWriter.write(imageMetaData, new IIOImage(bufferedImage, null, null), jpegParams);
}
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
public ImageWriteParam getDefaultWriteParam() {
return new JPEGImageWriteParam(null);
}
private byte[] getImagesBase64Bytes(JasperReport report, JasperPrint jasperPrint) {
logger.debug("IN");
byte[] bytes = new byte[0];
try {
String message = "<IMAGES>";
List bufferedImages = generateReportImages(report, jasperPrint);
Iterator iterImgs = bufferedImages.iterator();
int count = 1;
while (iterImgs.hasNext()) {
message += "<IMAGE page=\"" + count + "\">";
BufferedImage image = (BufferedImage) iterImgs.next();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageWriter imageWriter = ImageIO.getImageWritersBySuffix("jpeg").next();
ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
imageWriter.setOutput(ios);
IIOMetadata imageMetaData = imageWriter.getDefaultImageMetadata(new ImageTypeSpecifier(image), null);
ImageWriteParam par = imageWriter.getDefaultWriteParam();
par.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
par.setCompressionQuality(1.0f);
imageWriter.write(imageMetaData, new IIOImage(image, null, null), par);
// JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(baos);
// JPEGEncodeParam encodeParam = encoder.getDefaultJPEGEncodeParam(image);
// encodeParam.setQuality(1.0f, true);
// encoder.setJPEGEncodeParam(encodeParam);
// encoder.encode(image);
byte[] byteImg = baos.toByteArray();
baos.close();
BASE64Encoder encoder64 = new BASE64Encoder();
String encodedImage = encoder64.encode(byteImg);
message += encodedImage;
message += "</IMAGE>";
count++;
}
message += "</IMAGES>";
bytes = message.getBytes();
} catch (Exception e) {
logger.error("Error while producing byte64 encoding of the report images", e);
}
logger.debug("OUT");
return bytes;
}
@Override
public void exportReport() throws JRException {
byte[] bytes;
List bufferedImages;
try {
bytes = new byte[0];
String message = "<IMAGES>";
JasperReport report = (JasperReport) getParameter(JRImageExporterParameter.JASPER_REPORT);
JasperPrint jasperPrint = (JasperPrint) getParameter(JRExporterParameter.JASPER_PRINT);
bufferedImages = generateReportImages(report, jasperPrint);
Iterator iterImgs = bufferedImages.iterator();
int count = 1;
while (iterImgs.hasNext()) {
message += "<IMAGE page=\"" + count + "\">";
BufferedImage image = (BufferedImage) iterImgs.next();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageWriter imageWriter = ImageIO.getImageWritersBySuffix("jpeg").next();
ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
imageWriter.setOutput(ios);
IIOMetadata imageMetaData = imageWriter.getDefaultImageMetadata(new ImageTypeSpecifier(image), null);
ImageWriteParam par = imageWriter.getDefaultWriteParam();
par.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
par.setCompressionQuality(1.0f);
imageWriter.write(imageMetaData, new IIOImage(image, null, null), par);
// JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(baos);
// JPEGEncodeParam encodeParam = encoder.getDefaultJPEGEncodeParam(image);
// encodeParam.setQuality(1.0f, true);
// encoder.setJPEGEncodeParam(encodeParam);
// encoder.encode(image);
byte[] byteImg = baos.toByteArray();
baos.close();
BASE64Encoder encoder64 = new BASE64Encoder();
String encodedImage = encoder64.encode(byteImg);
message += encodedImage;
message += "</IMAGE>";
count++;
imageWriter.dispose();
}
message += "</IMAGES>";
bytes = message.getBytes();
OutputStream out = (OutputStream) getParameter(JRExporterParameter.OUTPUT_STREAM);
out.write(bytes);
} catch (Throwable t) {
throw new RuntimeException("Error while producing byte64 encoding of the report images", t);
}
}