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 javax.imageio.ImageIO;
  39 
  40 public class BitDepth {
  41 
  42     public static void main(String[] args) throws IOException {
  43         new BitDepth(args);
  44     }
  45 
  46     // Check that the PNG writer can write an all-white image correctly
  47     private static boolean testPNGByteBinary() throws IOException {
  48         int width = 10;
  49         int height = 10;
  50 
  51         File f = new File("BlackStripe.png");
  52         BufferedImage bi = new BufferedImage(width, height,
  53                                              BufferedImage.TYPE_BYTE_BINARY);
  54         Graphics2D g = bi.createGraphics();
  55         g.setColor(new Color(255, 255, 255));
  56         g.fillRect(0, 0, width, height);
  57 
  58         ImageIO.write(bi, "png", f);
  59         BufferedImage bi2 = ImageIO.read(f);
  60         if (bi2.getWidth() != width || bi2.getHeight() != height) {
  61             System.out.println("Dimensions changed!");
  62             return false;
  63         }
  64 
  65         for (int y = 0; y < height; y++) {
  66             for (int x = 0; x < width; x++) {
  67                 int rgb = bi2.getRGB(x, y);
  68                 if (rgb != 0xffffffff) {
  69                     System.out.println("Found a non-white pixel!");
  70                     return false;
  71                 }
  72             }
  73         }
  74 
  75         f.delete();
  76         return true;
  77     }
  78 
  79     private static final int[] biRGBTypes = {
  80         BufferedImage.TYPE_INT_RGB,
  81         BufferedImage.TYPE_INT_BGR,
  82         BufferedImage.TYPE_3BYTE_BGR,
  83         BufferedImage.TYPE_USHORT_565_RGB,
  84         BufferedImage.TYPE_USHORT_555_RGB,
  85         BufferedImage.TYPE_INT_ARGB,
  86         BufferedImage.TYPE_INT_ARGB_PRE,
  87         BufferedImage.TYPE_4BYTE_ABGR,
  88         BufferedImage.TYPE_4BYTE_ABGR_PRE
  89     };
  90 
  91     //private static final int[] biGrayTypes = {
  92     //    BufferedImage.TYPE_BYTE_GRAY,
  93     //    BufferedImage.TYPE_USHORT_GRAY,
  94     //    BufferedImage.TYPE_BYTE_BINARY
  95     //};
  96 
  97 
  98     private static final String[] biTypeNames = {
  99         "CUSTOM",
 100         "INT_RGB",
 101         "INT_ARGB",
 102         "INT_ARGB_PRE",
 103         "INT_BGR",
 104         "3BYTE_BGR",
 105         "4BYTE_ABGR",
 106         "4BYTE_ABGR_PRE",
 107         "USHORT_565_RGB",
 108         "USHORT_555_RGB",
 109         "BYTE_GRAY",
 110         "USHORT_GRAY",
 111         "BYTE_BINARY",
 112         "BYTE_INDEXED"
 113     };
 114 
 115     private int width = 80;
 116     private int height = 80;
 117     private String[] format = { "png", "jpeg", "tif", "bmp", "gif" };
 118 
 119     public BitDepth(String[] args) throws IOException {
 120         if (args.length > 0) {
 121             format = args;
 122         }
 123 
 124         for (int i = 0; i < format.length; i++) {
 125             testFormat(format[i]);
 126         }
 127     }
 128 
 129     private void testFormat(String format) throws IOException {
 130 
 131         boolean allOK = true;
 132 
 133         for (int i = 0; i < biRGBTypes.length; i++) {
 134 
 135             int type = biRGBTypes[i];
 136 
 137 
 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 
 152             System.out.println("Testing " + format +
 153                                " writer for type " + biTypeNames[type]);
 154             File f = testWriteRGB(format, type);
 155             boolean ok = testReadRGB(f);
 156             if (ok) {
 157                 f.delete();
 158             }
 159             allOK = allOK && ok;
 160         }
 161 
 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         File file = new File("BitDepth_" + biTypeNames[type] + "." + format);
 195         try {
 196             ImageIO.write(bi, format, file);
 197         } catch (RuntimeException re) {
 198             System.out.println("Can't write a type "
 199                                + biTypeNames[type] +
 200                                " BufferedImage!");
 201         }
 202 
 203         return file;
 204     }
 205 
 206     private int colorDistance(int color, int r, int g, int b) {
 207         int r0 = ((color >> 16) & 0xff) - r;
 208         int g0 = ((color >> 8) & 0xff) - g;
 209         int b0 = (color & 0xff) - b;
 210         return r0*r0 + g0*g0 + b0*b0;
 211     }
 212 
 213     private boolean testReadRGB(File file) throws IOException {
 214         int[] rgb = new int[3];
 215 
 216         BufferedImage bi = ImageIO.read(file);
 217         if (bi == null) {
 218             System.out.println("Couldn't read image!");
 219             return false;
 220         }
 221         int r = bi.getRGB(15, 15);
 222         if (colorDistance(r, 255, 0, 0) > 20) {
 223             System.out.println("Red was distorted!");
 224             return false;
 225         }
 226         int g = bi.getRGB(35, 35);
 227         if (colorDistance(g, 0, 255, 0) > 20) {
 228             System.out.println("Green was distorted!");
 229             return false;
 230         }
 231         int b = bi.getRGB(55, 55);
 232         if (colorDistance(b, 0, 0, 255) > 20) {
 233             System.out.println("Blue was distorted!");
 234             return false;
 235         }
 236         int w = bi.getRGB(55, 15);
 237         if (colorDistance(w, 255, 255, 255) > 20) {
 238             System.out.println("White was distorted!");
 239             return false;
 240         }
 241 
 242         return true;
 243     }
 244 }