1 /*
   2  * Copyright (c) 2007, 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 /**
  25  * @test
  26  * @bug     4413109 4418221 6607198 8147448
  27  * @run     main BitDepth
  28  * @summary Checks that ImageIO writers for standard formats can handle
  29  *          various BufferedImage RGB types. An optional list of arguments
  30  *          may be used to test the writers for a different list of formats.
  31  */
  32 
  33 import java.awt.Color;
  34 import java.awt.Graphics2D;
  35 import java.awt.image.BufferedImage;
  36 import java.io.File;
  37 import java.io.IOException;
  38 import java.util.Iterator;
  39 import javax.imageio.ImageIO;
  40 import javax.imageio.ImageTypeSpecifier;
  41 import javax.imageio.ImageWriter;
  42 import javax.imageio.stream.ImageOutputStream;
  43 
  44 public class BitDepth {
  45 
  46     public static void main(String[] args) throws IOException {
  47         new BitDepth(args);
  48     }
  49 
  50     // Check that the PNG writer can write an all-white image correctly
  51     private static boolean testPNGByteBinary() throws IOException {
  52         int width = 10;
  53         int height = 10;
  54 
  55         File f = new File("BlackStripe.png");
  56         BufferedImage bi = new BufferedImage(width, height,
  57                                              BufferedImage.TYPE_BYTE_BINARY);
  58         Graphics2D g = bi.createGraphics();
  59         g.setColor(new Color(255, 255, 255));
  60         g.fillRect(0, 0, width, height);
  61 
  62         ImageIO.write(bi, "png", f);
  63         BufferedImage bi2 = ImageIO.read(f);
  64         if (bi2.getWidth() != width || bi2.getHeight() != height) {
  65             System.out.println("Dimensions changed!");
  66             return false;
  67         }
  68 
  69         for (int y = 0; y < height; y++) {
  70             for (int x = 0; x < width; x++) {
  71                 int rgb = bi2.getRGB(x, y);
  72                 if (rgb != 0xffffffff) {
  73                     System.out.println("Found a non-white pixel!");
  74                     return false;
  75                 }
  76             }
  77         }
  78 
  79         f.delete();
  80         return true;
  81     }
  82 
  83     private static final int[] biRGBTypes = {
  84         BufferedImage.TYPE_INT_RGB,
  85         BufferedImage.TYPE_INT_BGR,
  86         BufferedImage.TYPE_3BYTE_BGR,
  87         BufferedImage.TYPE_USHORT_565_RGB,
  88         BufferedImage.TYPE_USHORT_555_RGB,
  89         BufferedImage.TYPE_INT_ARGB,
  90         BufferedImage.TYPE_INT_ARGB_PRE,
  91         BufferedImage.TYPE_4BYTE_ABGR,
  92         BufferedImage.TYPE_4BYTE_ABGR_PRE
  93     };
  94 
  95     //private static final int[] biGrayTypes = {
  96     //    BufferedImage.TYPE_BYTE_GRAY,
  97     //    BufferedImage.TYPE_USHORT_GRAY,
  98     //    BufferedImage.TYPE_BYTE_BINARY
  99     //};
 100 
 101 
 102     private static final String[] biTypeNames = {
 103         "CUSTOM",
 104         "INT_RGB",
 105         "INT_ARGB",
 106         "INT_ARGB_PRE",
 107         "INT_BGR",
 108         "3BYTE_BGR",
 109         "4BYTE_ABGR",
 110         "4BYTE_ABGR_PRE",
 111         "USHORT_565_RGB",
 112         "USHORT_555_RGB",
 113         "BYTE_GRAY",
 114         "USHORT_GRAY",
 115         "BYTE_BINARY",
 116         "BYTE_INDEXED"
 117     };
 118 
 119     private int width = 80;
 120     private int height = 80;
 121     private String[] formats = { "png", "jpeg", "tif", "bmp", "gif" };
 122 
 123     public BitDepth(String[] args) throws IOException {
 124         if (args.length > 0) {
 125             formats = args;
 126         }
 127 
 128         for (String format : formats) {
 129             testFormat(format);
 130         }
 131     }
 132 
 133     private void testFormat(String format) throws IOException {
 134 
 135         boolean allOK = true;
 136 
 137         for (int type : biRGBTypes) {
 138             // TODO: remove the following 'if' block after the 8147448 fix
 139             if ( format.toLowerCase().equals("bmp") && (
 140                 (type == BufferedImage.TYPE_INT_ARGB       ) ||
 141                 (type == BufferedImage.TYPE_INT_ARGB_PRE   ) ||
 142                 (type == BufferedImage.TYPE_4BYTE_ABGR     ) ||
 143                 (type == BufferedImage.TYPE_4BYTE_ABGR_PRE ))) {
 144 
 145                 System.err.println("cannot use " + biTypeNames[type] +
 146                 " for bmp because of JDK-8147448.\t" +
 147                 " please update the test after fix of this bug!");
 148                 continue;
 149             }
 150 
 151             System.out.println("Testing " + format +
 152                                " writer for type " + biTypeNames[type]);
 153             File f = testWriteRGB(format, type);
 154             if (f == null)
 155                 continue;
 156 
 157             boolean ok = testReadRGB(f);
 158             if (ok) {
 159                 f.delete();
 160             }
 161             allOK = allOK && ok;
 162         }
 163 
 164         if (format.equals("png")) {
 165             System.out.println("Testing png writer for black stripe");
 166             boolean ok = testPNGByteBinary();
 167             allOK = allOK && ok;
 168         }
 169 
 170         if (!allOK) {
 171             throw new RuntimeException("Test failed");
 172         }
 173     }
 174 
 175     private File testWriteRGB(String format, int type) throws IOException {
 176 
 177         BufferedImage bi = new BufferedImage(width, height, type);
 178         Graphics2D g = bi.createGraphics();
 179 
 180         Color white = new Color(255, 255, 255);
 181         Color red = new Color(255, 0, 0);
 182         Color green = new Color(0, 255, 0);
 183         Color blue = new Color(0, 0, 255);
 184 
 185         g.setColor(white);
 186         g.fillRect(0, 0, width, height);
 187         g.setColor(red);
 188         g.fillRect(10, 10, 20, 20);
 189         g.setColor(green);
 190         g.fillRect(30, 30, 20, 20);
 191         g.setColor(blue);
 192         g.fillRect(50, 50, 20, 20);
 193 
 194         ImageTypeSpecifier spec = new ImageTypeSpecifier(bi);
 195         Iterator<ImageWriter> writers = ImageIO.getImageWriters(spec, format);
 196         File file = new File("BitDepth_" + biTypeNames[type] + "." + format);
 197         if (!writers.hasNext()) {
 198             System.out.println("\tNo writers available for type " + biTypeNames[type]
 199                                + " BufferedImage!");
 200         } else {
 201             ImageWriter writer = writers.next();
 202             try (ImageOutputStream out = ImageIO.createImageOutputStream(file)) {
 203                 writer.setOutput(out);
 204                 writer.write(bi);
 205             } catch (Exception e) {
 206                 System.out.println("\tCan't write a type " +  biTypeNames[type]
 207                            + " BufferedImage!");
 208                 return null;
 209             }
 210         }
 211 
 212         return file;
 213     }
 214 
 215     private int colorDistance(int color, int r, int g, int b) {
 216         int r0 = ((color >> 16) & 0xff) - r;
 217         int g0 = ((color >> 8) & 0xff) - g;
 218         int b0 = (color & 0xff) - b;
 219         return r0*r0 + g0*g0 + b0*b0;
 220     }
 221 
 222     private boolean testReadRGB(File file) throws IOException {
 223         int[] rgb = new int[3];
 224 
 225         BufferedImage bi = ImageIO.read(file);
 226         if (bi == null) {
 227             System.out.println("Couldn't read image!");
 228             return false;
 229         }
 230         int r = bi.getRGB(15, 15);
 231         if (colorDistance(r, 255, 0, 0) > 20) {
 232             System.out.println("Red was distorted!");
 233             return false;
 234         }
 235         int g = bi.getRGB(35, 35);
 236         if (colorDistance(g, 0, 255, 0) > 20) {
 237             System.out.println("Green was distorted!");
 238             return false;
 239         }
 240         int b = bi.getRGB(55, 55);
 241         if (colorDistance(b, 0, 0, 255) > 20) {
 242             System.out.println("Blue was distorted!");
 243             return false;
 244         }
 245         int w = bi.getRGB(55, 15);
 246         if (colorDistance(w, 255, 255, 255) > 20) {
 247             System.out.println("White was distorted!");
 248             return false;
 249         }
 250 
 251         return true;
 252     }
 253 }