--- /dev/null 2015-12-10 21:45:44.216350012 +0100 +++ new/test/javax/imageio/plugins/shared/ImageWriterCompressionTest.java 2015-12-11 00:40:17.391061483 +0100 @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.awt.Color; +import java.awt.Font; +import java.awt.Graphics2D; +import java.awt.RenderingHints; +import java.awt.geom.Rectangle2D; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Locale; +import java.util.Set; +import javax.imageio.IIOImage; +import javax.imageio.ImageIO; +import javax.imageio.ImageWriteParam; +import javax.imageio.ImageWriter; +import javax.imageio.stream.ImageOutputStream; + +/** + * @test @bug 6488522 + * @summary Check the compression support in imageio ImageWriters + * @run main ImageWriterCompressionTest + */ +public class ImageWriterCompressionTest { + + // ignore jpg (fail): + // Caused by: javax.imageio.IIOException: Invalid argument to native writeImage + // ignore tiff (fail): + // Caused by: javax.imageio.IIOException: Invalid argument to native writeImage + private static final Set IGNORE_FILE_SUFFIXES + = new HashSet(Arrays.asList(new String[] { + "bmp", "gif", + "jpg", "jpeg", +// "tif", "tiff" + } )); + + public static void main(String[] args) { + Locale.setDefault(Locale.US); + + final BufferedImage image + = new BufferedImage(512, 512, BufferedImage.TYPE_INT_ARGB); + + final Graphics2D g2d = image.createGraphics(); + try { + g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + g2d.setRenderingHint(RenderingHints.KEY_RENDERING, + RenderingHints.VALUE_RENDER_QUALITY); + g2d.scale(2.0, 2.0); + + g2d.setColor(Color.red); + g2d.draw(new Rectangle2D.Float(10, 10, 100, 100)); + g2d.setColor(Color.blue); + g2d.fill(new Rectangle2D.Float(12, 12, 98, 98)); + g2d.setColor(Color.green); + g2d.setFont(new Font(Font.SERIF, Font.BOLD, 14)); + + for (int i = 0; i < 15; i++) { + g2d.drawString("Testing Compression ...", 20, 20 + i * 16); + } + + final String[] fileSuffixes = ImageIO.getWriterFileSuffixes(); + + final Set testedWriterClasses = new HashSet(); + + for (String suffix : fileSuffixes) { + + if (!IGNORE_FILE_SUFFIXES.contains(suffix)) { + final Iterator itWriters + = ImageIO.getImageWritersBySuffix(suffix); + + final ImageWriter writer; + final ImageWriteParam writerParams; + + if (itWriters.hasNext()) { + writer = itWriters.next(); + + if (testedWriterClasses.add(writer.getClass().getName())) { + writerParams = writer.getDefaultWriteParam(); + + if (writerParams.canWriteCompressed()) { + testCompression(image, writer, writerParams, suffix); + } + } + } else { + throw new RuntimeException("Unable to get writer !"); + } + } + } + + } catch (IOException ioe) { + throw new RuntimeException("IO failure", ioe); + } + finally { + g2d.dispose(); + } + } + + private static void testCompression(final BufferedImage image, + final ImageWriter writer, + final ImageWriteParam writerParams, + final String suffix) + throws IOException + { + System.out.println("Compression types: " + + Arrays.toString(writerParams.getCompressionTypes())); + + // Test Compression modes: + try { + writerParams.setCompressionMode(ImageWriteParam.MODE_DISABLED); + saveImage(image, writer, writerParams, "disabled", suffix); + } catch (Exception e) { + System.out.println("CompressionMode Disabled not supported: "+ e.getMessage()); + } + + try { + writerParams.setCompressionMode(ImageWriteParam.MODE_DEFAULT); + saveImage(image, writer, writerParams, "default", suffix); + } catch (Exception e) { + System.out.println("CompressionMode Default not supported: "+ e.getMessage()); + } + + writerParams.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); + writerParams.setCompressionType(selectCompressionType(suffix, + writerParams.getCompressionTypes())); + + System.out.println("Selected Compression type: " + + writerParams.getCompressionType()); + + long prev = Long.MAX_VALUE; + for (int i = 10; i >= 0; i--) { + float quality = 0.1f * i; + writerParams.setCompressionQuality(quality); + + long len = saveImage(image, writer, writerParams, + String.format("explicit-%.1f", quality), suffix); + + if (len <= 0) { + throw new RuntimeException("zero file length !"); + } else if (len > prev) { + throw new RuntimeException("Incorrect file length: " + len + + " larger than previous: " + prev + " !"); + } + prev = len; + } + } + + private static String selectCompressionType(final String suffix, + final String[] types) + { + switch (suffix) { + case "tif": + case "tiff": + return "LZW"; + default: + return types[0]; + } + } + + private static long saveImage(final BufferedImage image, + final ImageWriter writer, + final ImageWriteParam writerParams, + final String mode, + final String suffix) throws IOException + { + final File imgFile = new File("WriterCompressionTest-" + + mode + '.' + suffix); + System.out.println("Writing file: " + imgFile.getAbsolutePath()); + + final ImageOutputStream imgOutStream + = ImageIO.createImageOutputStream(new FileOutputStream(imgFile)); + try { + writer.setOutput(imgOutStream); + writer.write(null, new IIOImage(image, null, null), writerParams); + } finally { + imgOutStream.close(); + } + return imgFile.length(); + } +}