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 * @test
25 * @key headful
26 * @bug 6514990
27 * @summary Verifies that calling
28 * Graphics2D.drawImage(BufferedImage, BufferedImageOp, x, y) to an
29 * OpenGL-accelerated destination produces the same results when performed
30 * in software via BufferedImageOp.filter().
31 * @run main/othervm -Dsun.java2d.opengl=True DrawBufImgOp -ignore
32 * @author campbelc
33 */
34
35 import java.awt.*;
36 import java.awt.image.*;
37 import java.io.File;
38 import javax.imageio.ImageIO;
39
40 /**
41 * REMIND: This testcase was originally intended to automatically compare
42 * the results of the software BufferedImageOp implementations against
43 * the OGL-accelerated codepaths. However, there are just too many open
44 * bugs in the mediaLib-based codepaths (see below), which means that
45 * creating the reference image may cause crashes or exceptions,
46 * and even if we work around those cases using the "-ignore" flag,
47 * the visual results of the reference image are often buggy as well
48 * (so the comparison will fail even though the OGL results are correct).
49 * Therefore, for now we will run the testcase with the "-ignore" flag
50 * but without the "-compare" flag, so at least it will be checking for
51 * any exceptions/crashes in the OGL code. When we fix all of the
52 * outstanding bugs with the software codepaths, we can remove the
53 * "-ignore" flag and maybe even restore the "-compare" flag. In the
54 * meantime, it stil functions well as a manual testcase (with either
55 * the "-show" or "-dump" options).
56 */
57 public class DrawBufImgOp extends Canvas {
58
59 private static final int TESTW = 600;
60 private static final int TESTH = 500;
61 private static boolean done;
62
63 /*
64 * If true, skips tests that are known to trigger bugs (which in
65 * turn may cause crashes, exceptions, or other artifacts).
66 */
67 private static boolean ignore;
68
69 // Test both pow2 and non-pow2 sized images
70 private static final int[] srcSizes = { 32, 17 };
71 private static final int[] srcTypes = {
72 BufferedImage.TYPE_INT_RGB,
73 BufferedImage.TYPE_INT_ARGB,
74 BufferedImage.TYPE_INT_ARGB_PRE,
75 BufferedImage.TYPE_INT_BGR,
76 BufferedImage.TYPE_3BYTE_BGR,
77 BufferedImage.TYPE_4BYTE_ABGR,
78 BufferedImage.TYPE_USHORT_565_RGB,
79 BufferedImage.TYPE_BYTE_GRAY,
80 BufferedImage.TYPE_USHORT_GRAY,
81 };
82
83 private static final RescaleOp
84 rescale1band, rescale3band, rescale4band;
85 private static final LookupOp
86 lookup1bandbyte, lookup3bandbyte, lookup4bandbyte;
87 private static final LookupOp
88 lookup1bandshort, lookup3bandshort, lookup4bandshort;
89 private static final ConvolveOp
90 convolve3x3zero, convolve5x5zero, convolve7x7zero;
91 private static final ConvolveOp
92 convolve3x3noop, convolve5x5noop, convolve7x7noop;
93
94 static {
95 rescale1band = new RescaleOp(0.5f, 10.0f, null);
96 rescale3band = new RescaleOp(
97 new float[] { 0.6f, 0.4f, 0.6f },
98 new float[] { 10.0f, -3.0f, 5.0f },
99 null);
100 rescale4band = new RescaleOp(
101 new float[] { 0.6f, 0.4f, 0.6f, 0.9f },
102 new float[] { -1.0f, 5.0f, 3.0f, 1.0f },
103 null);
104
105 // REMIND: we should probably test non-zero offsets, but that
106 // would require massaging the source image data to avoid going
107 // outside the lookup table array bounds
108 int offset = 0;
109 {
110 byte invert[] = new byte[256];
111 byte halved[] = new byte[256];
112 for (int j = 0; j < 256 ; j++) {
113 invert[j] = (byte) (255-j);
114 halved[j] = (byte) (j / 2);
115 }
116 ByteLookupTable lut1 = new ByteLookupTable(offset, invert);
117 lookup1bandbyte = new LookupOp(lut1, null);
118 ByteLookupTable lut3 =
119 new ByteLookupTable(offset,
120 new byte[][] {invert, halved, invert});
121 lookup3bandbyte = new LookupOp(lut3, null);
122 ByteLookupTable lut4 =
123 new ByteLookupTable(offset,
124 new byte[][] {invert, halved, invert, halved});
125 lookup4bandbyte = new LookupOp(lut4, null);
126 }
127
128 {
129 short invert[] = new short[256];
130 short halved[] = new short[256];
131 for (int j = 0; j < 256 ; j++) {
132 invert[j] = (short) ((255-j) * 255);
133 halved[j] = (short) ((j / 2) * 255);
134 }
135 ShortLookupTable lut1 = new ShortLookupTable(offset, invert);
136 lookup1bandshort = new LookupOp(lut1, null);
137 ShortLookupTable lut3 =
138 new ShortLookupTable(offset,
139 new short[][] {invert, halved, invert});
140 lookup3bandshort = new LookupOp(lut3, null);
141 ShortLookupTable lut4 =
142 new ShortLookupTable(offset,
143 new short[][] {invert, halved, invert, halved});
144 lookup4bandshort = new LookupOp(lut4, null);
145 }
146
147 // 3x3 blur
148 float[] data3 = {
149 0.1f, 0.1f, 0.1f,
150 0.1f, 0.2f, 0.1f,
151 0.1f, 0.1f, 0.1f,
152 };
153 Kernel k3 = new Kernel(3, 3, data3);
154
155 // 5x5 edge
156 float[] data5 = {
157 -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
158 -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
159 -1.0f, -1.0f, 24.0f, -1.0f, -1.0f,
160 -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
161 -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
162 };
163 Kernel k5 = new Kernel(5, 5, data5);
164
165 // 7x7 blur
166 float[] data7 = {
167 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f,
168 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f,
169 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f,
170 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f,
171 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f,
172 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f,
173 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f, 0.02f,
174 };
175 Kernel k7 = new Kernel(7, 7, data7);
176
177 convolve3x3zero = new ConvolveOp(k3, ConvolveOp.EDGE_ZERO_FILL, null);
178 convolve5x5zero = new ConvolveOp(k5, ConvolveOp.EDGE_ZERO_FILL, null);
179 convolve7x7zero = new ConvolveOp(k7, ConvolveOp.EDGE_ZERO_FILL, null);
180
181 convolve3x3noop = new ConvolveOp(k3, ConvolveOp.EDGE_NO_OP, null);
182 convolve5x5noop = new ConvolveOp(k5, ConvolveOp.EDGE_NO_OP, null);
183 convolve7x7noop = new ConvolveOp(k7, ConvolveOp.EDGE_NO_OP, null);
184 }
185
186 public void paint(Graphics g) {
187 synchronized (this) {
188 if (done) {
189 return;
190 }
191 }
192
193 VolatileImage vimg = createVolatileImage(TESTW, TESTH);
194 vimg.validate(getGraphicsConfiguration());
195
196 Graphics2D g2d = vimg.createGraphics();
197 renderTest(g2d);
198 g2d.dispose();
199
200 g.drawImage(vimg, 0, 0, null);
201
202 Toolkit.getDefaultToolkit().sync();
203
204 synchronized (this) {
205 done = true;
206 notifyAll();
207 }
208 }
209
210 /*
211 * foreach source image size (once with pow2, once with non-pow2)
212 *
213 * foreach BufferedImage type
214 *
215 * RescaleOp (1 band)
216 * RescaleOp (3 bands, if src has 3 bands)
217 * RescaleOp (4 bands, if src has 4 bands)
218 *
219 * foreach LookupTable type (once with ByteLUT, once with ShortLUT)
220 * LookupOp (1 band)
221 * LookupOp (3 bands, if src has 3 bands)
222 * LookupOp (4 bands, if src has 4 bands)
223 *
224 * foreach edge condition (once with ZERO_FILL, once with EDGE_NO_OP)
225 * ConvolveOp (3x3)
226 * ConvolveOp (5x5)
227 * ConvolveOp (7x7)
228 */
229 private void renderTest(Graphics2D g2d) {
230 g2d.setColor(Color.white);
231 g2d.fillRect(0, 0, TESTW, TESTH);
232
233 int yorig = 2;
234 int xinc = 34;
235 int yinc = srcSizes[0] + srcSizes[1] + 2 + 2;
236
237 for (int srcType : srcTypes) {
238 int y = yorig;
239
240 for (int srcSize : srcSizes) {
241 int x = 2;
242 System.out.printf("type=%d size=%d\n", srcType, srcSize);
243
244 BufferedImage srcImg = makeSourceImage(srcSize, srcType);
245 ColorModel srcCM = srcImg.getColorModel();
246
247 // RescaleOp
248 g2d.drawImage(srcImg, rescale1band, x, y);
249 x += xinc;
250 // REMIND: 3-band RescaleOp.filter() throws IAE for images
251 // that contain an alpha channel (bug to be filed)
252 if (srcCM.getNumColorComponents() == 3 &&
253 !(ignore && srcCM.hasAlpha()))
254 {
255 g2d.drawImage(srcImg, rescale3band, x, y);
256 }
257 x += xinc;
258 if (srcCM.getNumComponents() == 4) {
259 g2d.drawImage(srcImg, rescale4band, x, y);
260 }
261 x += xinc;
262
263 // LookupOp
264 // REMIND: Our LUTs are only 256 elements long, so won't
265 // currently work with USHORT_GRAY data
266 if (srcType != BufferedImage.TYPE_USHORT_GRAY) {
267 g2d.drawImage(srcImg, lookup1bandbyte, x, y);
268 x += xinc;
269 if (srcCM.getNumColorComponents() == 3) {
270 g2d.drawImage(srcImg, lookup3bandbyte, x, y);
271 }
272 x += xinc;
273 if (srcCM.getNumComponents() == 4) {
274 g2d.drawImage(srcImg, lookup4bandbyte, x, y);
275 }
276 x += xinc;
277
278 // REMIND: LookupOp.createCompatibleDestImage() throws
279 // IAE for 3BYTE_BGR/4BYTE_ABGR (bug to be filed)
280 if (!(ignore &&
281 (srcType == BufferedImage.TYPE_3BYTE_BGR ||
282 srcType == BufferedImage.TYPE_4BYTE_ABGR)))
283 {
284 g2d.drawImage(srcImg, lookup1bandshort, x, y);
285 x += xinc;
286 // REMIND: 3-band LookupOp.filter() throws IAE for
287 // images that contain an alpha channel
288 // (bug to be filed)
289 if (srcCM.getNumColorComponents() == 3 &&
290 !(ignore && srcCM.hasAlpha()))
291 {
292 g2d.drawImage(srcImg, lookup3bandshort, x, y);
293 }
294 x += xinc;
295 if (srcCM.getNumComponents() == 4) {
296 g2d.drawImage(srcImg, lookup4bandshort, x, y);
297 }
298 x += xinc;
299 } else {
300 x += 3*xinc;
301 }
302 } else {
303 x += 6*xinc;
304 }
305
306 // ConvolveOp
307 // REMIND: ConvolveOp.filter() throws ImagingOpException
308 // for 3BYTE_BGR (see 4957775)
309 if (srcType != BufferedImage.TYPE_3BYTE_BGR) {
310 g2d.drawImage(srcImg, convolve3x3zero, x, y);
311 x += xinc;
312 g2d.drawImage(srcImg, convolve5x5zero, x, y);
313 x += xinc;
314 g2d.drawImage(srcImg, convolve7x7zero, x, y);
315 x += xinc;
316
317 g2d.drawImage(srcImg, convolve3x3noop, x, y);
318 x += xinc;
319 g2d.drawImage(srcImg, convolve5x5noop, x, y);
320 x += xinc;
321 g2d.drawImage(srcImg, convolve7x7noop, x, y);
322 x += xinc;
323 } else {
324 x += 6*xinc;
325 }
326
327 y += srcSize + 2;
328 }
329
330 yorig += yinc;
331 }
332 }
333
334 private BufferedImage makeSourceImage(int size, int type) {
335 int s2 = size/2;
336 BufferedImage img = new BufferedImage(size, size, type);
337 Graphics2D g2d = img.createGraphics();
338 g2d.setComposite(AlphaComposite.Src);
339 g2d.setColor(Color.orange);
340 g2d.fillRect(0, 0, size, size);
341 g2d.setColor(Color.red);
342 g2d.fillRect(0, 0, s2, s2);
343 g2d.setColor(Color.green);
344 g2d.fillRect(s2, 0, s2, s2);
345 g2d.setColor(Color.blue);
346 g2d.fillRect(0, s2, s2, s2);
347 g2d.setColor(new Color(255, 255, 0, 128));
348 g2d.fillRect(s2, s2, s2, s2);
349 g2d.setColor(Color.pink);
350 g2d.fillOval(s2-3, s2-3, 6, 6);
351 g2d.dispose();
352 return img;
353 }
354
355 public BufferedImage makeReferenceImage() {
356 BufferedImage img = new BufferedImage(TESTW, TESTH,
357 BufferedImage.TYPE_INT_RGB);
358 Graphics2D g2d = img.createGraphics();
359 renderTest(g2d);
360 g2d.dispose();
361 return img;
362 }
363
364 public Dimension getPreferredSize() {
365 return new Dimension(TESTW, TESTH);
366 }
367
368 private static void compareImages(BufferedImage refImg,
369 BufferedImage testImg,
370 int tolerance)
371 {
372 int x1 = 0;
373 int y1 = 0;
374 int x2 = refImg.getWidth();
375 int y2 = refImg.getHeight();
376
377 for (int y = y1; y < y2; y++) {
378 for (int x = x1; x < x2; x++) {
379 Color expected = new Color(refImg.getRGB(x, y));
380 Color actual = new Color(testImg.getRGB(x, y));
381 if (!isSameColor(expected, actual, tolerance)) {
382 throw new RuntimeException("Test failed at x="+x+" y="+y+
383 " (expected="+expected+
384 " actual="+actual+
385 ")");
386 }
387 }
388 }
389 }
390
391 private static boolean isSameColor(Color c1, Color c2, int e) {
392 int r1 = c1.getRed();
393 int g1 = c1.getGreen();
394 int b1 = c1.getBlue();
395 int r2 = c2.getRed();
396 int g2 = c2.getGreen();
397 int b2 = c2.getBlue();
398 int rmin = Math.max(r2-e, 0);
399 int gmin = Math.max(g2-e, 0);
400 int bmin = Math.max(b2-e, 0);
401 int rmax = Math.min(r2+e, 255);
402 int gmax = Math.min(g2+e, 255);
403 int bmax = Math.min(b2+e, 255);
404 if (r1 >= rmin && r1 <= rmax &&
405 g1 >= gmin && g1 <= gmax &&
406 b1 >= bmin && b1 <= bmax)
407 {
408 return true;
409 }
410 return false;
411 }
412
413 public static void main(String[] args) throws Exception {
414 boolean show = false;
415 boolean dump = false;
416 boolean compare = false;
417
418 for (String arg : args) {
419 if (arg.equals("-show")) {
420 show = true;
421 } else if (arg.equals("-dump")) {
422 dump = true;
423 } else if (arg.equals("-compare")) {
424 compare = true;
425 } else if (arg.equals("-ignore")) {
426 ignore = true;
427 }
428 }
429
430 DrawBufImgOp test = new DrawBufImgOp();
431 Frame frame = new Frame();
432 frame.add(test);
433 frame.pack();
434 frame.setVisible(true);
435
436 // Wait until the component's been painted
437 synchronized (test) {
438 while (!done) {
439 try {
440 test.wait();
441 } catch (InterruptedException e) {
442 throw new RuntimeException("Failed: Interrupted");
443 }
444 }
445 }
446
447 GraphicsConfiguration gc = frame.getGraphicsConfiguration();
448 if (gc.getColorModel() instanceof IndexColorModel) {
449 System.out.println("IndexColorModel detected: " +
450 "test considered PASSED");
451 frame.dispose();
452 return;
453 }
454
455 // Grab the screen region
456 BufferedImage capture = null;
457 try {
458 Robot robot = new Robot();
459 Point pt1 = test.getLocationOnScreen();
460 Rectangle rect = new Rectangle(pt1.x, pt1.y, TESTW, TESTH);
461 capture = robot.createScreenCapture(rect);
462 } catch (Exception e) {
463 throw new RuntimeException("Problems creating Robot");
464 } finally {
465 if (!show) {
466 frame.dispose();
467 }
468 }
469
470 // Compare the images (allow for +/- 1 bit differences in color comps)
471 if (dump || compare) {
472 BufferedImage ref = test.makeReferenceImage();
473 if (dump) {
474 ImageIO.write(ref, "png",
475 new File("DrawBufImgOp.ref.png"));
476 ImageIO.write(capture, "png",
477 new File("DrawBufImgOp.cap.png"));
478 }
479 if (compare) {
480 test.compareImages(ref, capture, 1);
481 }
482 }
483 }
484 }