IncorrectAlphaSurface2SW.java revision 14851:980da45565c8 
1/*
2 * Copyright (c) 2014, 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
24import java.awt.AlphaComposite;
25import java.awt.Color;
26import java.awt.Graphics2D;
27import java.awt.GraphicsConfiguration;
28import java.awt.GraphicsEnvironment;
29import java.awt.Image;
30import java.awt.image.BufferedImage;
31import java.awt.image.VolatileImage;
32import java.io.File;
33import java.io.IOException;
34
35import javax.imageio.ImageIO;
36
37import static java.awt.Transparency.TRANSLUCENT;
38import static java.awt.image.BufferedImage.TYPE_4BYTE_ABGR;
39import static java.awt.image.BufferedImage.TYPE_4BYTE_ABGR_PRE;
40import static java.awt.image.BufferedImage.TYPE_INT_ARGB;
41import static java.awt.image.BufferedImage.TYPE_INT_ARGB_PRE;
42
43/**
44 * @test
45 * @key headful
46 * @bug 8017626
47 * @summary Tests drawing transparent volatile image to transparent BI.
48 *          Results of the blit compatibleImage to transparent BI used for
49 *          comparison.
50 * @author Sergey Bylokhov
51 */
52public final class IncorrectAlphaSurface2SW {
53
54    private static final int[] SCALES = {1, 2, 4, 8};
55    private static final int[] SIZES = {1, 2, 3, 127, 128, 254, 255, 256};
56    private static final int[] dstTypes = {TYPE_INT_ARGB, TYPE_INT_ARGB_PRE,
57            TYPE_4BYTE_ABGR, TYPE_4BYTE_ABGR_PRE};
58    private static final int[] srcTypes = {TRANSLUCENT};
59
60
61    public static void main(final String[] args) throws IOException {
62        GraphicsEnvironment ge = GraphicsEnvironment
63                .getLocalGraphicsEnvironment();
64        GraphicsConfiguration gc = ge.getDefaultScreenDevice()
65                                     .getDefaultConfiguration();
66        BufferedImage destVI;
67        BufferedImage destBI;
68        BufferedImage sourceBI;
69        VolatileImage sourceVI;
70
71        for (final int s : SIZES) {
72            for (final int srcType : srcTypes) {
73                for (final int dstType : dstTypes) {
74                    for (final int scale : SCALES) {
75                        int sw = s * scale;
76                        destVI = new BufferedImage(sw, sw, dstType);
77                        destBI = new BufferedImage(sw, sw, dstType);
78                        sourceBI = gc.createCompatibleImage(sw, sw, srcType);
79                        sourceVI = gc.createCompatibleVolatileImage(s, s, srcType);
80
81                        // draw to dest BI using compatible image
82                        fill(sourceBI, s);
83                        Graphics2D big = destBI.createGraphics();
84                        big.setComposite(AlphaComposite.Src);
85                        big.drawImage(sourceBI, 0, 0, sw, sw, null);
86                        big.dispose();
87
88                        // draw to dest BI using compatible image
89                        fill(sourceVI, s);
90                        drawVItoBI(gc, destVI, sourceVI);
91
92                        validate(destVI, destBI);
93                        sourceVI.flush();
94                    }
95                }
96            }
97        }
98        System.out.println("Test PASSED");
99    }
100
101    private static void drawVItoBI(GraphicsConfiguration gc,
102                                   BufferedImage bi, VolatileImage vi) {
103        while (true) {
104            vi.validate(gc);
105            fill(vi, vi.getHeight());
106            if (vi.validate(gc) != VolatileImage.IMAGE_OK) {
107                try {
108                    Thread.sleep(100);
109                } catch (final InterruptedException ignored) {
110                }
111                continue;
112            }
113
114            Graphics2D big = bi.createGraphics();
115            big.setComposite(AlphaComposite.Src);
116            big.drawImage(vi, 0, 0, bi.getWidth(), bi.getHeight(), null);
117            big.dispose();
118
119            if (vi.contentsLost()) {
120                try {
121                    Thread.sleep(100);
122                } catch (final InterruptedException ignored) {
123                }
124                continue;
125            }
126            break;
127        }
128    }
129
130    private static void validate(BufferedImage bi, BufferedImage gold)
131            throws IOException {
132        for (int x = 0; x < bi.getWidth(); ++x) {
133            for (int y = 0; y < bi.getHeight(); ++y) {
134                if (gold.getRGB(x, y) != bi.getRGB(x, y)) {
135                    System.err.println("Expected color = " + gold.getRGB(x, y));
136                    System.err.println("Actual color = " + bi.getRGB(x, y));
137                    ImageIO.write(gold, "png", new File("gold.png"));
138                    ImageIO.write(bi, "png", new File("bi.png"));
139                    throw new RuntimeException("Test failed.");
140                }
141            }
142        }
143    }
144
145    /**
146     * Fills the whole image using different alpha for each row.
147     *
148     * @param image to fill
149     */
150    private static void fill(final Image image, final int size) {
151        Graphics2D graphics = (Graphics2D) image.getGraphics();
152        graphics.setComposite(AlphaComposite.Src);
153        graphics.setColor(Color.GREEN);
154        graphics.fillRect(0, 0, image.getWidth(null), image.getHeight(null));
155        int row = image.getHeight(null) / size;
156        for (int i = 0; i < size; ++i) {
157            graphics.setColor(new Color(23, 127, 189, i));
158            graphics.fillRect(0, i * row, image.getWidth(null), row);
159        }
160        graphics.dispose();
161    }
162}
163