1 /*
   2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.awt.Color;
  25 import java.awt.Font;
  26 import java.awt.Graphics2D;
  27 import java.awt.RenderingHints;
  28 import java.awt.geom.Rectangle2D;
  29 import java.awt.image.BufferedImage;
  30 import java.io.File;
  31 import java.io.FileOutputStream;
  32 import java.io.IOException;
  33 import java.util.Arrays;
  34 import java.util.HashSet;
  35 import java.util.Iterator;
  36 import java.util.Locale;
  37 import java.util.Set;
  38 import javax.imageio.IIOImage;
  39 import javax.imageio.ImageIO;
  40 import javax.imageio.ImageWriteParam;
  41 import javax.imageio.ImageWriter;
  42 import javax.imageio.stream.ImageOutputStream;
  43 
  44 /**
  45  * @test
  46  * @bug 6488522
  47  * @summary Check the compression support in imageio ImageWriters
  48  * @run main ImageWriterCompressionTest
  49  */
  50 public class ImageWriterCompressionTest {
  51 
  52     // ignore jpg (fail):
  53     // Caused by: javax.imageio.IIOException: Invalid argument to native writeImage
  54     private static final Set<String> IGNORE_FILE_SUFFIXES
  55         = new HashSet<String>(Arrays.asList(new String[] {
  56             "bmp", "gif",
  57             "jpg", "jpeg"
  58         } ));
  59 
  60     public static void main(String[] args) {
  61         Locale.setDefault(Locale.US);
  62 
  63         final BufferedImage image
  64             = new BufferedImage(512, 512, BufferedImage.TYPE_INT_ARGB);
  65 
  66         final Graphics2D g2d = image.createGraphics();
  67         try {
  68             g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  69                                  RenderingHints.VALUE_ANTIALIAS_ON);
  70             g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
  71                                  RenderingHints.VALUE_RENDER_QUALITY);
  72             g2d.scale(2.0, 2.0);
  73 
  74             g2d.setColor(Color.red);
  75             g2d.draw(new Rectangle2D.Float(10, 10, 100, 100));
  76             g2d.setColor(Color.blue);
  77             g2d.fill(new Rectangle2D.Float(12, 12, 98, 98));
  78             g2d.setColor(Color.green);
  79             g2d.setFont(new Font(Font.SERIF, Font.BOLD, 14));
  80 
  81             for (int i = 0; i < 15; i++) {
  82                 g2d.drawString("Testing Compression ...", 20, 20 + i * 16);
  83             }
  84 
  85             final String[] fileSuffixes = ImageIO.getWriterFileSuffixes();
  86 
  87             final Set<String> testedWriterClasses = new HashSet<String>();
  88 
  89             for (String suffix : fileSuffixes) {
  90 
  91                 if (!IGNORE_FILE_SUFFIXES.contains(suffix)) {
  92                     final Iterator<ImageWriter> itWriters
  93                         = ImageIO.getImageWritersBySuffix(suffix);
  94 
  95                     final ImageWriter writer;
  96                     final ImageWriteParam writerParams;
  97 
  98                     if (itWriters.hasNext()) {
  99                         writer = itWriters.next();
 100 
 101                         if (testedWriterClasses.add(writer.getClass().getName())) {
 102                             writerParams = writer.getDefaultWriteParam();
 103 
 104                             if (writerParams.canWriteCompressed()) {
 105                                 testCompression(image, writer, writerParams, suffix);
 106                             }
 107                         }
 108                     } else {
 109                         throw new RuntimeException("Unable to get writer !");
 110                     }
 111                 }
 112             }
 113         } catch (IOException ioe) {
 114             throw new RuntimeException("IO failure", ioe);
 115         }
 116         finally {
 117             g2d.dispose();
 118         }
 119     }
 120 
 121     private static void testCompression(final BufferedImage image,
 122                                         final ImageWriter writer,
 123                                         final ImageWriteParam writerParams,
 124                                         final String suffix)
 125         throws IOException
 126     {
 127         System.out.println("Compression types: "
 128             + Arrays.toString(writerParams.getCompressionTypes()));
 129 
 130         // Test Compression modes:
 131         try {
 132             writerParams.setCompressionMode(ImageWriteParam.MODE_DISABLED);
 133             saveImage(image, writer, writerParams, "disabled", suffix);
 134         } catch (Exception e) {
 135             System.out.println("CompressionMode Disabled not supported: "+ e.getMessage());
 136         }
 137 
 138         try {
 139             writerParams.setCompressionMode(ImageWriteParam.MODE_DEFAULT);
 140             saveImage(image, writer, writerParams, "default", suffix);
 141         } catch (Exception e) {
 142             System.out.println("CompressionMode Default not supported: "+ e.getMessage());
 143         }
 144 
 145         writerParams.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
 146         writerParams.setCompressionType(selectCompressionType(suffix,
 147                         writerParams.getCompressionTypes()));
 148 
 149         System.out.println("Selected Compression type: "
 150             + writerParams.getCompressionType());
 151 
 152         long prev = Long.MAX_VALUE;
 153         for (int i = 10; i >= 0; i--) {
 154             float quality = 0.1f * i;
 155             writerParams.setCompressionQuality(quality);
 156 
 157             long len = saveImage(image, writer, writerParams,
 158                                  String.format("explicit-%.1f", quality), suffix);
 159 
 160             if (len <= 0) {
 161                 throw new RuntimeException("zero file length !");
 162             } else if (len > prev) {
 163                 throw new RuntimeException("Incorrect file length: " + len
 164                     + " larger than previous: " + prev + " !");
 165             }
 166             prev = len;
 167         }
 168     }
 169 
 170     private static String selectCompressionType(final String suffix,
 171                                                 final String[] types)
 172     {
 173         switch (suffix) {
 174             case "tif":
 175             case "tiff":
 176                 return "LZW";
 177             default:
 178                 return types[0];
 179         }
 180     }
 181 
 182     private static long saveImage(final BufferedImage image,
 183                                   final ImageWriter writer,
 184                                   final ImageWriteParam writerParams,
 185                                   final String mode,
 186                                   final String suffix) throws IOException
 187     {
 188         final File imgFile = new File("WriterCompressionTest-"
 189                                       + mode + '.' + suffix);
 190         System.out.println("Writing file: " + imgFile.getAbsolutePath());
 191 
 192         final ImageOutputStream imgOutStream
 193             = ImageIO.createImageOutputStream(new FileOutputStream(imgFile));
 194         try {
 195             writer.setOutput(imgOutStream);
 196             writer.write(null, new IIOImage(image, null, null), writerParams);
 197         } finally {
 198             imgOutStream.close();
 199         }
 200         return imgFile.length();
 201     }
 202 }