--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/imageio/plugins/png/GrayPngTest.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/**
+ * @test
+ * @bug 6557713
+ * @summary Test verifies that PNG image writer correctly handles indexed images with
+ * various types of transparency.
+ *
+ * Test for 4bpp OPAQUE image
+ * @run main GrayPngTest 4 1 3
+ *
+ * Test for 4bpp BITMASK image with transparent pixel 3
+ * @run main GrayPngTest 4 2 3
+ *
+ * Test for 4bpp TRANSLUCENT image
+ * @run main GrayPngTest 4 3 3
+ *
+ * Test for 8bpp OPAQUE image
+ * @run main GrayPngTest 8 1 127
+ *
+ * Test for 8bpp BITMASK image with transparent pixel 127
+ * @run main GrayPngTest 8 2 127
+ *
+ * Test for 8bpp TRANSLUCENT image
+ * @run main GrayPngTest 8 3 127
+ *
+ */
+
+import java.awt.Color;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.IndexColorModel;
+import java.awt.image.WritableRaster;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import javax.imageio.ImageIO;
+
+public class GrayPngTest {
+
+ public static void main(String[] args) throws IOException {
+ /*
+ * Expected argiments:
+ * args[0] - bits per pixel. Supported range: [1, 8]
+ * args[1] - transparency type. Should be one form
+ * java.awt.Transparency type constants.
+ * args[2] - transparent pixel for BITMASK transparency type,
+ * otherwise is ignored.
+ */
+ int bpp = 4;
+ int trans_type = Transparency.BITMASK;
+ int trans_pixel = 3;
+ try {
+ bpp = Integer.parseInt(args[0]);
+ trans_type = Integer.parseInt(args[1]);
+ trans_pixel = Integer.parseInt(args[2]);
+ } catch (NumberFormatException e) {
+ System.out.println("Ignore ncorrect bpp value: " + args[0]);
+ } catch (ArrayIndexOutOfBoundsException e) {
+ System.out.println("Default test argumens.");
+ }
+
+ new GrayPngTest(bpp).doTest(trans_type, trans_pixel);
+ }
+
+
+
+ private BufferedImage getTestImage(int trans_type, int trans_pixel) {
+
+ IndexColorModel icm = null;
+ switch(trans_type) {
+ case Transparency.OPAQUE:
+ icm = new IndexColorModel(bpp, numColors, r, g, b);
+ break;
+ case Transparency.BITMASK:
+ icm = new IndexColorModel(bpp, numColors, r, g, b, trans_pixel);
+ break;
+ case Transparency.TRANSLUCENT:
+ a = Arrays.copyOf(r, r.length);
+ icm = new IndexColorModel(bpp, numColors, r, g, b, a);
+ break;
+ default:
+ throw new RuntimeException("Invalid transparency: " + trans_type);
+ }
+
+ int w = 256 * 2;
+ int h = 200;
+
+ dx = w / (numColors);
+
+ WritableRaster wr = icm.createCompatibleWritableRaster(w, h);
+ for (int i = 0; i < numColors; i ++) {
+ int rx = i * dx;
+
+ int[] samples = new int[h * dx];
+ Arrays.fill(samples, i);
+ wr.setPixels(rx, 0, dx, h, samples);
+ }
+
+ // horizontal line with transparent color
+ int[] samples = new int[w * 10];
+ Arrays.fill(samples, trans_pixel);
+ wr.setPixels(0, h / 2 - 5, w, 10, samples);
+
+ // create index color model
+ return new BufferedImage(icm, wr, false, null);
+ }
+
+ static File pwd = new File(".");
+
+ private BufferedImage src;
+ private BufferedImage dst;
+ private int bpp;
+ private int numColors;
+
+ private int dx;
+
+ private byte[] r;
+ private byte[] g;
+ private byte[] b;
+
+ private byte[] a;
+
+ protected GrayPngTest(int bpp) {
+ if (0 > bpp || bpp > 8) {
+ throw new RuntimeException("Invalid bpp: " + bpp);
+ }
+ this.bpp = bpp;
+ numColors = (1 << bpp);
+ System.out.println("Num colors: " + numColors);
+
+ // create palette
+ r = new byte[numColors];
+ g = new byte[numColors];
+ b = new byte[numColors];
+
+ int dc = 0xff / (numColors - 1);
+ System.out.println("dc = " + dc);
+
+ for (int i = 0; i < numColors; i ++) {
+ byte l = (byte)(i * dc);
+ r[i] = l; g[i] = l; b[i] = l;
+ }
+ }
+
+ public void doTest() throws IOException {
+ for (int i = 0; i < numColors; i++) {
+ doTest(Transparency.BITMASK, i);
+ }
+ }
+
+ public void doTest(int trans_type, int trans_index) throws IOException {
+ src = getTestImage(trans_type, trans_index);
+
+ System.out.println("src: " + src);
+
+ File f = File.createTempFile("gray_png_" + bpp + "bpp_" +
+ trans_type + "tt_" +
+ trans_index + "tp_", ".png", pwd);
+ System.out.println("File: " + f.getAbsolutePath());
+ if (!ImageIO.write(src, "png", f)) {
+ throw new RuntimeException("Writing failed!");
+ };
+
+ try {
+ dst = ImageIO.read(f);
+ System.out.println("dst: " + dst);
+ } catch (Exception e) {
+ throw new RuntimeException("Test FAILED.", e);
+ }
+
+ checkImages();
+ }
+
+ private void checkImages() {
+ for (int i = 0; i < numColors; i++) {
+ int src_rgb = src.getRGB(i * dx, 5);
+ int dst_rgb = dst.getRGB(i * dx, 5);
+
+ // here we check transparency only due to possible colors space
+ // differences (sRGB in indexed source and Gray in gray+alpha destination)
+ if ((0xff000000 & src_rgb) != (0xff000000 & dst_rgb)) {
+ throw new RuntimeException("Test FAILED. Color difference detected: " +
+ Integer.toHexString(dst_rgb) + " instead of " +
+ Integer.toHexString(src_rgb) + " for index " + i);
+
+ }
+ }
+ }
+}